Re: How to check a Float for NaN

[Adam Beneschan <adam@irvine.com>]

On Apr 30, 3:50 am, christoph.gr...@eurocopter.com wrote:
> On 30 Apr., 12:47, christoph.gr...@eurocopter.com wrote:
>
> > Try Float'Valid (X), see RM 13.9.2
>
> Ahem, I meant X'Valid for X of type Float

I'm not sure if this will produce the desired results, since it should
return False for +/- infinity also.  That may be OK with the original
poster, or not.

The problem here is that if you're dealing with NaN's on purpose,
you're not really dealing with Ada, as far as I can tell, unless your
purpose is to test for an uninitialized variable (in which case
X'Valid makes sense).  Otherwise, though, NaN's and infinities are not
possible values of floating-point types, and therefore they can't be
returned by operations that return floating-point values, even if
Float'Machine_Overflows is False.  (There are certain passages in the
RM that say a result is implementation-defined if the
Machine_Overflows attribute is False; however, I do not think
assigning a variable to an invalid value, as a NaN would be, is an
allowed "implementation-defined" result.  13.9.2(4-11) lists the ways
that invalid data could be created, and the "result of a floating-
point operation that cannot return a valid result" is not one of those
listed.  Yes, I know that this is a NOTE and is not normative.)

Of course, if you compile with checking turned off or your code does
something to turn off the floating-point overflow-checking bit in the
processor (if there is one), you're outside the bounds of Ada, so you
can't really come up with an Ada solution to the question, and
whatever you do won't be portable.  In that case, "whatever works" is
fine.  If I had to do this, I'd just do an Unchecked_Conversion to
some data structure with a rep clause that represents an  IEEE-754
float, or to a modular integer type or array of modular integer types,
and then just test the bits myself.  Testing the 'Image for "NaN" will
probably work, but if efficiency is a concern I wouldn't do this
because if the float is a valid one, it's a *lot* of work to convert
the float to a decimal representation, and that's especially painful
here because you're just going to throw all that work out.

P.S. Has the ARG or anyone discussed the possibility of building
support for infinities and/or NaN's into the language---i.e. defining
a floating-point type that includes those "values"?  G.1.1(56) makes
me think that maybe there were some thoughts that this might be done
sometime in the future, if there's a demand for it, but I could be
reading something into this paragraph that isn't there.

                                   -- Adam