Re: Bug converting numbers?

[Pierre Weis <Pierre.Weis@inria.fr>]

> Hello - Bonjour!
> 
> I have encountered unexpected behaviour converting integers to floats:
> 
> # let x = 7.;;
> val x : float = 7
> # let y = float 7;;
> val y : float = 7
> # x == y;;
> - : bool = false
> 
> The internal representation of "7." is obviously different to "float 7".
> Is there some reason to it? This makes it hard to write things like:
> 
> if a_float == float (truncate a_float) ...
> 
> if one wants to check whether a float can actually be represented as
> an integer...

For a more exhaustive discussion on this problem, see the Caml FAQ:
<http://caml.inria.fr/FAQ/FAQ_EXPERT-eng.html#egalite>.

The problem here is that you missed the right equality predicate: you
must use = instead of ==. Remember that == means unicity of
representation, not semantical equality of values. For instance:

# "ok" == "ok";;
- : bool = false

"ok" is not the same object as (another) "ok". In contrast, "ok" is
equal to (any other) "ok":

# "ok" = "ok";; 
- : bool = true

So there is no problem of floating point numbers conversion, since the
same (unexpected ?) behaviour still apply if we remove conversions:

# 1.0 == 1.0;;
- : bool = false

(it means that floats may be allocated and then stored in different memory
locations).

Using = your predicate works fine:

let represented_has_an_integer f = f = float (truncate f);;
val represented_has_an_integer : float -> bool = <fun>

And now:

# represented_has_an_integer 7.0;;
- : bool = true

Remember that the == predicate is not for casual uses: you should know
something about value representations in your Caml system to use it
safely. In doubt, use the regular = predicate.

> français:
> La représentation de "7." et évidemment differente de "float 7".
> Est-ce qu'il y a une raison? C'est un problème si on veut verifier si un
> "float" peut être représenté comme "int"...

Pour une discussion plus complète du problème voir
<http://caml.inria.fr/FAQ/FAQ_EXPERT-fra.html#egalite>.

Le comportement que vous observez vient de ce que les flottants sont
des structures de données (généralement) allouées en mémoire. Or vous
utilisez le prédicat == qui teste l'identité physique, au lieu de =
qui teste l'égalité sémantique. Le test == donne alors des résultats
surprenants:

# 1.0 == 1.0;;
- : bool = false

Il suffit d'utiliser = pour que tout rentre dans l'ordre.

Pierre Weis

INRIA, Projet Cristal, Pierre.Weis@inria.fr, http://cristal.inria.fr/~weis/