Hi,

I am not really sure wether there is a better group for this. I already

tried a VC group, but they cannot tell me how other stdlibs are doing

it.

I tested a lot with inf and NaNs. I read some docs from docs.sun.com

about the standard. It seems to be an commented inerpretation of the

IEEE standard.

So it seems my VC.net's standard c++ library is not really meeting the

standard, or the standard is not what I think.

I found out that:

the numeric_limits<double> knows only a infinite which is the standards

+inf.

it knows a sNaN which is different from the one in the standard, it is

rather the same as the standards -inf

if I calculate d = d / 0 I get what numeric_limit says is the sNaN. This

is fine even though the bit pattern is different from the standard, but

I can use it just as is.

But, d = -d * d returns the same bit pattern. In this case it is

returning the standards -inf as ist should, but there is no -inf in the

numeric_limits of the library.

All in all the behaviour is weird, but the only problem is, that I can

not distinguish between -inf and sNaN. Whis is in case of some matrix

caclulations the difference between division by zero and division by

some very small ( neg ) number.

Is someone familiar with this topic, or can tell me about his version of

the stdlib or compiler, or can point me to another interpretation of the

IEEE standard?

Here is the code that I used to examine the problem:

#include <iostream>

#include <math.h>

#include <limits>

using namespace std;

const __int64 NAN_BITS = 0x7ff0000000000000;

bool IsNAN( const double d )

{

return ( ( *reinterpret_cast<const __int64*>( &d ) & NAN_BITS ) ==

NAN_BITS )

&& ( *reinterpret_cast<const __int64*>( &d ) != NAN_BITS );

}

void hexout( void* p )

{

cout << "\t";

cout.width( 8 );

cout.fill( '0' );

long* pl = (long*)p;

cout << hex << pl[1] << " ";

cout.width( 8 );

cout.fill( '0' );

cout << hex << pl[0] << endl;

}

template< typename T >

void report( )

{

cout << "numeric_limits<double>::\n" << endl;

double

d = numeric_limits<T>::denorm_min( ); cout << "denorm_min = ";

hexout( &d );

// d = numeric_limits<T>::denorm_max( ); cout << "denorm_max = ";

// hexout( &d );

d = numeric_limits<T>::epsilon( ); cout << "epsilon = ";

hexout( &d );

d = numeric_limits<T>::infinity( ); cout << "infinity = ";

hexout( &d );

// cout << "is_bounded = " << numeric_limits<T>::is_bounded( ) <<

endl;

// cout << "is_exact = " << numeric_limits<T>::is_exact( ) << endl;

// cout << "is_iec559 = " << numeric_limits<T>::is_iec559( ) << endl;

d = numeric_limits<T>::max( ); cout << "max =

\t";

hexout( &d );

d = numeric_limits<T>::min( ); cout << "min =

\t";

hexout( &d );

d = numeric_limits<T>::quiet_NaN( );cout << "quiet_NaN = ";

hexout( &d );

d = numeric_limits<T>::signaling_NaN( );cout << "signaling_NaN =

";

hexout( &d );

// produce an infinite number:

d = numeric_limits<T>::max( ); d = d * d;cout << "pos inf = \t";

hexout( &d );

cout << "Is positive infinity NaN ? " << IsNAN( d ) << endl;

d = numeric_limits<T>::max( ); d = -d * d;cout << "neg inf = \t";

hexout( &d );

cout << "Is negative infinity NaN ? " << IsNAN( d ) << endl;

d = d / 0;

cout << "Div by zero returns: "; hexout( &d );

cout << "Is div by zero NaN ? " << IsNAN( d ) << endl;

}

int main(int argc, char* argv[])

{

report< double >( );

cout << endl << endl;

cout << "sizeof( float ) = " << sizeof( float ) << endl;

cout << "sizeof( double ) = " << sizeof( double ) << endl;

cout << "sizeof( long double ) = " << sizeof( long double ) <<

endl;

getchar( );

return 0;

}