CCRandom
include module type of struct include Random end
Initialize the generator, using the argument as a seed. The same seed will always yield the same sequence of numbers.
Initialize the generator with a random seed chosen in a system-dependent way. If /dev/urandom
is available on the host machine, it is used to provide a highly random initial seed. Otherwise, a less random seed is computed from system parameters (current time, process IDs).
Random.int32 bound
returns a random integer between 0 (inclusive) and bound
(exclusive). bound
must be greater than 0.
val nativeint : Nativeint.t -> Nativeint.t
Random.nativeint bound
returns a random integer between 0 (inclusive) and bound
(exclusive). bound
must be greater than 0.
Random.int64 bound
returns a random integer between 0 (inclusive) and bound
(exclusive). bound
must be greater than 0.
The functions from module State
manipulate the current state of the random generator explicitly. This allows using one or several deterministic PRNGs, even in a multi-threaded program, without interference from other parts of the program.
module State : sig ... end
val get_state : unit -> State.t
Return the current state of the generator used by the basic functions.
val set_state : State.t -> unit
Set the state of the generator used by the basic functions.
type state = Random.State.t
type 'a t = state -> 'a
Random generator for values of type 'a
.
type 'a random_gen = 'a t
val return : 'a -> 'a t
return x
is the generator that always returns x
. Example: let random_int = return 4 (* fair dice roll *)
.
Delay evaluation. Useful for side-effectful generators that need some code to run for every call. Example:
let gensym = let r = ref 0 in fun () -> incr r; !r ;;
delay (fun () ->
let name = gensym() in
small_int >>= fun i -> return (name,i)
)
val choose_return : 'a list -> 'a t
Choose among the list.
replicate n g
makes a list of n
elements which are all generated randomly using g
.
sample_without_replacement n g
makes a list of n
elements which are all generated randomly using g
with the added constraint that none of the generated random values are equal.
val pick_list : 'a list -> 'a t
Pick an element at random from the list.
val pick_array : 'a array -> 'a t
Pick an element at random from the array.
val small_int : int t
A small int (100).
val int : int -> int t
Random int within the given range.
val int_range : int -> int -> int t
Inclusive range.
val small_float : float t
A reasonably small float (100.0).
val float : float -> float t
Random float within the given range.
val float_range : float -> float -> float t
Inclusive range. float_range a b
assumes a < b
.
val split : int -> (int * int) option t
Split a positive value n
into n1,n2
where n = n1 + n2
.
val split_list : int -> len:int -> int list option t
Split a value n
into a list of values whose sum is n
and whose length is length
. The list is never empty and does not contain 0
.
retry g
calls g
until it returns some value, or until the maximum number of retries was reached. If g
fails, then it counts for one iteration, and the generator retries.
try_successively l
tries each generator of l
, one after the other. If some generator succeeds its result is returned, else the next generator is tried.
a <?> b
is a choice operator. It first tries a
, and returns its result if successful. If a
fails, then b
is returned.
val fix : ?sub1:('a t -> 'a t) list -> ?sub2:('a t -> 'a t -> 'a t) list ->
?subn:(int t * ('a list t -> 'a t)) list -> base:'a t -> int t -> 'a t
Recursion combinators, for building recursive values. The integer generator is used to provide fuel. The sub_
generators should use their arguments only once!
val pure : 'a -> 'a t
Let operators on OCaml >= 4.08.0, nothing otherwise