Accueil     À propos     Téléchargement     Ressources     Contactez-nous

Ce site est rarement mis à jour. Pour les informations les plus récentes, rendez-vous sur le nouveau site OCaml à l'adresse ocaml.org.

Random questions
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
 Date: 2009-12-03 (14:48) From: Daniel_BÃ¼nzli Subject: Re: [Caml-list] Random questions
```Hello Cedric,

> let rint () = (Random.bits () lsl 1) lxor (Random.bits ());;

That was actually my first version. However I dropped it because I
thought that generating a new random number by the interaction of the
bits of two successive PRN could somehow change the underlying quality
of the generator. Any thought ?

> if Random.bool is more efficient than Random.bits, the latter seems the
> best; to be benchmarked

Random.bool is Random.bits () land 0 = 1.

>> 2) Generate an arbitrary int in [0;max] (bounds included)
>>
>> let random_uint ?(max = max_int) =
>> Â if max < 0 then invalid_arg "negative max" else
>> Â if max = max_int then Random.bits else
>> Â let bound = max + 1 in
>> Â fun () -> Random.int bound
>
> Seems correct.
> I don't know if use of exception is more efficient or not, it is to try:
>
> let random_uint ?(max = max_int) () =
> Â try if max = max_int then Random.bits () else Random.int (max + 1)
> Â with Invalid_argument "Random.int" -> invalid_arg "negative max"

You lose the ability to partially apply random_uint with the max and
avoid the if on each call.

> I think it is better to use the bool trick;
> simpler and doesn't use Int32:
>
> let random_int ?(max = max_int) =
> Â  if max < 0 then invalid_arg "negative max" else
> Â  if max = 0 then 0 else
> Â  if Random.bool ()
> Â  then if max = max_int then Random.bits ()
> Â  Â  Â  Â else Random.int max
> Â  else negate_minus_1 (Random.int (max - 1)) (* inline? *)
>

Yes, thanks. Your version can also be reordered to be partially applicable.

It should also be noted that all our functions for [int]s don't work
with the intended semantics on 64 bits platforms.

>> 5) Generate an arbitrary float in [0;max] (bounds included)
>>
>> let after_one = 1. +. epsilon_float
>> let random_ufloat ?(max = max_float) =
>> Â if max < 0. then invalid_arg "negative max" else
>> Â fun () -> (Random.float after_one) *. max
>
> This function is less interesting than Random.float:
> only less or as many as values as floats in [0.;1.] can be generated
> so you will miss many values only to be able to produce max
> (for example, you cannot 1+eps if you try random_ufloat ~max:2. ())

The point you make maybe valid but unfortunately that's also the case
for Random.float as this is the way it is implemented (generate a
number in [0;1[ and scale it).

Best,

Daniel

```