[Caml-list] NaN-safe min and max

[Caml-list] NaN-safe min and max

[Yaron Minsky]

Olivier Andrieu proposed the following code for doing a safe min/max. 
Does anyone have any thoughts about this code snippet, and whether it is
or is not a safe use of Obj.magic?

 let min a b =
    let o = Obj.repr a in
    if Obj.is_block o && Obj.tag o = Obj.double_tag
    then Obj.magic (fmin (Obj.magic a) (Obj.magic b))
    else Pervasives.min a b

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] NaN-safe min and max

[Remi Vanicat]

"Yaron Minsky" <yminsky@cs.cornell.edu> writes:

> Olivier Andrieu proposed the following code for doing a safe min/max. 
> Does anyone have any thoughts about this code snippet, and whether it is
> or is not a safe use of Obj.magic?
>
>  let min a b =
>     let o = Obj.repr a in
>     if Obj.is_block o && Obj.tag o = Obj.double_tag
>     then Obj.magic (fmin (Obj.magic a) (Obj.magic b))
>     else Pervasives.min a b

this one is unsafe : the fact that a is a block with a tag
Obj.double_tag doesn't proof that the same is true for b even if a and
b have the same type :

# let i1 = Lazy.lazy_from_val 0.0;;
val i1 : float Lazy.t = lazy 0.
# let o1 = Obj.repr i1;;
val o1 : Obj.t = <abstr>
# Obj.is_block o1;;
- : bool = true
# Obj.tag o1 = Obj.double_tag;;
- : bool = true
# let i2 = lazy 3;;
val i2 : int lazy_t = <lazy>
# let o2 = Obj.repr i2;;
val o2 : Obj.t = <abstr>
# Obj.is_block o2;;
- : bool = true
#  Obj.tag o2 = Obj.double_tag;;
- : bool = false

both i1 and i2 have the same type, but only the first one is a block of
tag Obj.double_tag. A verification have to be done for both argument.
-- 
Rémi Vanicat
remi.vanicat@laposte.net

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] NaN-safe min and max

[Remi Vanicat]

Remi Vanicat <vanicat@labri.u-bordeaux.fr> writes:

> "Yaron Minsky" <yminsky@cs.cornell.edu> writes:
>
>> Olivier Andrieu proposed the following code for doing a safe min/max. 
>> Does anyone have any thoughts about this code snippet, and whether it is
>> or is not a safe use of Obj.magic?
>>
>>  let min a b =
>>     let o = Obj.repr a in
>>     if Obj.is_block o && Obj.tag o = Obj.double_tag
>>     then Obj.magic (fmin (Obj.magic a) (Obj.magic b))
>>     else Pervasives.min a b
>
> this one is unsafe : the fact that a is a block with a tag
> Obj.double_tag doesn't proof that the same is true for b even if a and
> b have the same type :
>
> # let i1 = Lazy.lazy_from_val 0.0;;
> val i1 : float Lazy.t = lazy 0.
> # let o1 = Obj.repr i1;;
> val o1 : Obj.t = <abstr>
> # Obj.is_block o1;;
> - : bool = true
> # Obj.tag o1 = Obj.double_tag;;
> - : bool = true
> # let i2 = lazy 3;;
> val i2 : int lazy_t = <lazy>
> # let o2 = Obj.repr i2;;
> val o2 : Obj.t = <abstr>
> # Obj.is_block o2;;
> - : bool = true
> #  Obj.tag o2 = Obj.double_tag;;
> - : bool = false

> both i1 and i2 have the same type, but only the first one is a block of
> tag Obj.double_tag. A verification have to be done for both
> argument.

If you replace 
let i2 = lazy 3;;
by
let i2 = lazy 3.;;

then what I've said became true.

[...]


-- 
Rémi Vanicat
remi.vanicat@laposte.net

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] NaN-safe min and max

[Jacques Garrigue]

From: Remi Vanicat <vanicat@labri.u-bordeaux.fr>

> this one is unsafe : the fact that a is a block with a tag
> Obj.double_tag doesn't proof that the same is true for b even if a and
> b have the same type :
> 
> # let i1 = Lazy.lazy_from_val 0.0;;
> val i1 : float Lazy.t = lazy 0.
> # let o1 = Obj.repr i1;;
> val o1 : Obj.t = <abstr>
> # Obj.is_block o1;;
> - : bool = true
> # Obj.tag o1 = Obj.double_tag;;
> - : bool = true
> # let i2 = lazy 3;;
> val i2 : int lazy_t = <lazy>
> # let o2 = Obj.repr i2;;
> val o2 : Obj.t = <abstr>
> # Obj.is_block o2;;
> - : bool = true
> #  Obj.tag o2 = Obj.double_tag;;
> - : bool = false
> 
> both i1 and i2 have the same type, but only the first one is a block of
> tag Obj.double_tag. A verification have to be done for both argument.

Very interesting: you have found an unsoundness in the ocaml compiler.
Using your example combined with arrays we obtain:

# let arr = [|Lazy.lazy_from_val 0.0; lazy 1.0|];;
val arr : float Lazy.t array = [|lazy 0.; lazy 4.32681603021051e-311|]

i.e., the second lazy is assumed to be a float value, and results in a
wrong result (clearly 1.0 is not anything close to 4.32e-311)

So my take on this is that the code suggested for min is correct, this
is the compiler which is wrong: two values with the same type _must_
have the same representation.

A new headache for implementers...

   Jacques Garrigue

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners