Pseudo-random number generators (PRNG).
###### Basic functions
Note that all of these "basic" functions mutate a global random state.
`val init : `int -> unit``
Initialize the generator, using the argument as a seed. The same seed will always yield the same sequence of numbers.
`val full_init : `int array -> unit``
Same as Random.init but takes more data as seed.
`val self_init : `unit -> unit``
Initialize the generator with a more-or-less random seed chosen in a system-dependent way.
`val bits : `unit -> int``
Return 30 random bits in a nonnegative integer.Before 3.12.0 used a different algorithm (affects all the following functions)
`val int : `int -> int``
`Random.int bound` returns a random integer between 0 (inclusive) and `bound` (exclusive). `bound` must be greater than 0 and less than 230.
`val int32 : `Int32.t -> Int32.t``
`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.
`val int64 : `Int64.t -> Int64.t``
`Random.int64 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive). `bound` must be greater than 0.
`val float : `float -> float``
`Random.float bound` returns a random floating-point number between 0 (inclusive) and `bound` (exclusive). If `bound` is negative, the result is negative or zero. If `bound` is 0, the result is 0.
`val bool : `unit -> bool``
`Random.bool ()` returns `true` or `false` with probability 0.5 each.
`module State : `sig .. end``
The functions from module `State` manipulate the current state of the random generator explicitely. This allows using one or several deterministic PRNGs, even in a multi-threaded program, without interference from other parts of the program.
`type t`
`val default : `t``
`val make : `int array -> t``
Create a new state and initialize it with the given seed.
`val make_self_init : `unit -> t``
Create a new state and initialize it with a system-dependent low-entropy seed.
`val copy : `t -> t``
`val bits : `t -> int``
These functions are the same as the basic functions, except that they use (and update) the given PRNG state instead of the default one.
`val int : `t -> int -> int``
`val int32 : `t -> Int32.t -> Int32.t``
`val nativeint : `t -> Nativeint.t -> Nativeint.t``
`val int64 : `t -> Int64.t -> Int64.t``
`val float : `t -> float -> float``
`val bool : `t -> bool``
`val get_state : `unit -> [ `Consider_using_Random_State_default ]``
OCaml's `Random.get_state` makes a copy of the default state, which is almost certainly not what you want. `State.default`, which is the actual default state, is probably what you want.
`val set_state : `State.t -> unit``
Set the state of the generator used by the basic functions.