floating point verification using is?
Don
nospam at nospam.com
Mon Dec 28 18:52:24 PST 2009
Steven Schveighoffer wrote:
> On Mon, 28 Dec 2009 06:51:30 -0500, Don <nospam at nospam.com> wrote:
>
>> Stewart Gordon wrote:
>>> Steven Schveighoffer wrote:
>>> <snip>
>>>> Are you still working on this? :) I think this proves my point.
>>>> The compiler does not provide an easy way to compare floats bitwise,
>>>> so this means convoluted hard-to-write code. When we have two
>>>> operators that do equality -- and one of those means bitwise compare
>>>> in all other contexts -- I think this is a no-brainer.
>>> I entirely agree.
>>> I've identified these cases in which float equality disagrees with
>>> bitwise equality:
>>> - one is +0, one is -0
>>> - both are NaNs, identically signed
>>> - both are infinity, identically signed
>>> In each case, is just does the same as ==.
>>> Indeed, isIdentical is an ugly workaround for this, apparently
>>> created instead of sanitising the definition of is to avoid the
>>> minuscule amount of code breakage that the latter would effect.
>>
>> No, it was because I have write access to Phobos, but not to the
>> compiler...
>>
>> But, this isn't as simple as people are assuming. There's a problem in
>> the original request. We need to be clear about what T.init is. Is T.init
>> (a) the bit pattern which all variables of type T get default
>> initialized to? Or is it
>> (b) an arbitrary valid value for type T?
>> In the case of floats, they are NOT "default initialized" -- they are
>> marked as "not initialized". So there's a big question about whether
>> semantic (a) T.init actually makes sense.
>
> The answer is a. Whether you like it or not, the runtime must
> initialize it to something, even if the value means "uninitialized".
The key question is: is it valid to read an uninitialized variable? I
would hope the compiler would flag that as an error. The use of
signalling NaNs was based on the assumption that you should *never* be
reading uninitialized variables.
A consequence is that you should also NEVER read float.init!
> That value should always be consistent. There has to be a way to verify
> that the value was set properly. Otherwise, how do you verify things
> like communication protocols or expectations for runtime functions?
I think that sending an uninitialized variable down a communication
channel is always a bug.
> It has to be a bit pattern, because all other T.init values, including
> those of aggregates which might contain floating points, are bit patterns.
>
>> Consider this code:
>>
>> T x;
>> if (x==T.init) { writefln("x is uninitialized"); }
>>
>> Is this code valid? You are reading the value of an uninitialized
>> variable.
>
> Correct that to:
>
> T x;
> if(x is T.init) {writefln("x is uninitialized"); }
>
> Then I think it is valid. I don't care if == is hijacked away from
> bitwise comparison, in fact, it is necessary in many cases. But there
> should be a way to do bitwise comparison for verification, and 'is' fits
> the bill perfectly.
That does preclude a compiler from ever giving you errors/warnings about
using uninitialized variables. I think it's wrong.
More information about the Digitalmars-d-learn
mailing list