Re: How to check a Float for NaN

[Jerry <lanceboyle@qwest.net>]

On Apr 30, 8:02 am, Adam Beneschan <a...@irvine.com> wrote:
> 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

Thanks for the insight. From my point of view, not having access to
the all the IEEE-754 features is a nuisance. I'm not sure what I'm
going to do--probably try in import the C function isnan. My need
isn't terribly important--just converting an example for PLplot that
is written in C. Frankly, I'm a little surprised that this isn't
handled by Ada--but I'm sure there's an excellent reason ;).

FWIW, I just now found this passage from the Annotated ARM at
http://www.adaic.org/standards/05aarm/html/AA-A-5-1.html, in A.5.1,
34.b (IEC 559 = IEEE 754):

"Discussion: It is anticipated that an Ada binding to IEC 559:1989
will be developed in the future. As part of such a binding, the
Machine_Overflows attribute of a conformant floating point type will
be specified to yield False, which will permit both the predefined
arithmetic operations and implementations of the elementary functions
to deliver signed infinities (and set the overflow flag defined by the
binding) instead of raising Constraint_Error in overflow situations,
when traps are disabled. Similarly, it is appropriate for the
elementary functions to deliver signed infinities (and set the zero-
divide flag defined by the binding) instead of raising
Constraint_Error at poles, when traps are disabled. Finally, such a
binding should also specify the behavior of the elementary functions,
when sensible, given parameters with infinite values."

Jerry