Boost logo

Boost :

Subject: Re: [boost] [review][constrained_value] Review of Constrained Value Library begins today
From: Thorsten Ottosen (thorsten.ottosen_at_[hidden])
Date: 2008-12-11 11:45:39

Johan RÃ¥de skrev:
> Thorsten Ottosen wrote:
>> Johan RÃ¥de skrev:
>>> Robert Kawulak wrote:
>>>>> From: Johan Rade
>>>>> The statement is
>>>>> "x <= y before truncation implies x <= y after truncation".
>>>> Or more specifically:
>>>> "x < y before truncation implies x <= y after truncation"
>>>> Is this right?
>>>> _______________________________________________
>>>> Unsubscribe & other changes:
>>> Thought about it again.
>>> None if these statements are true, unfortunately,
>>> if you consider the case when one number is truncated to 64 bits
>>> and the other is kept at 80 bits.
>>> Then you can even have x < y before and x > y after.
>> Hm. This sucks.
>> Do we know if that 80-bit floating point values are guaranteed to be a
>> superset of 64-bit and 32-bit floats (or if 64-bit is a superset of
>> 32-bit floats).
>> I suspect the answer might be yes. If so, I don't think
>> x < y before ==> x > y after
>> can be true. If x is rounded upwards, y would be an upper bound.
> Imagine the following case,
> 1) x and y are stored in 80-bit registers
> 2) x < y
> 3) both x and y are just below 1.0,
> so close that they would be rounded to 1.0 if truncated to 64 bits
> If now x is truncated to 64 bits, and then moved back to an 80-bit
> register,
> while y is unchanged, then x > y.

We need to make either x or y one of the bounds of our interval. Let us
assume it is y.

Furthermore, we know y has been specified such that it is representable
exactly in float or double. Since the 80-bit floating point values are a
  superset, we know y can also be represented exactly in this format,
and we know that truncation on y will have no effect.

Basically, y will have the same value no matter if it is stored in a
register or at some memory location.

The question is know, can

   x < y

pass, and then x is assigned to the a bounded_float
(where it will be stored in x'), only to
discover that

  x' < y

? We know y will always have the same value, so only x may
switch location.

Case 1: x is in memory, x' is in register. Then x == x' by the superset

Case 2: x is in register, x' is register. Then x == x'.

Case 3: x is in register, x' is in memory. Then we might have x' == y,
but not x' > y, since that would violate the fact that y is exactly
representable in both formats.

Have I overlooked something?


Boost list run by bdawes at, gregod at, cpdaniel at, john at