## Basic functions

`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.

`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 full_int : int -> int`

`Random.full_int bound` returns a random integer between 0 (inclusive) and `bound` (exclusive). `bound` may be any positive integer.

If `bound` is less than 230, `Random.full_int bound` is equal to `Random.int` `bound`. If `bound` is greater than 230 (on 64-bit systems or non-standard environments, such as JavaScript), `Random.full_int` returns a value, where `Random.int` raises `Invalid_argument`.

- since 3.4.0 and OCaml 4.13.0

`val int_in_range : min:int -> max:int -> int`
`val int32 : Stdlib.Int32.t -> Stdlib.Int32.t`

`Random.int32 bound` returns a random integer between 0 (inclusive) and `bound` (exclusive). `bound` must be greater than 0.

`val int32_in_range : min:int32 -> max:int32 -> int32`
`val nativeint : Stdlib.Nativeint.t -> Stdlib.Nativeint.t`

`Random.nativeint bound` returns a random integer between 0 (inclusive) and `bound` (exclusive). `bound` must be greater than 0.

`val nativeint_in_range : min:nativeint -> max:nativeint -> nativeint`
`val int64 : Stdlib.Int64.t -> Stdlib.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 int64_in_range : min:int64 -> max:int64 -> int64`
`val bool : unit -> bool`

`Random.bool ()` returns `true` or `false` with probability 0.5 each.

`val char : unit -> char`

Return a random Latin-1 character.

`val full_range_int : unit -> int`

`full_range_int ()` returns the maximum entropy possible in a single int: 31 bits on 32-bit platforms and 63 bits on 64-bit platforms. Intentionally gives different results on different platforms, so is not portable.

## Enumerations of random values.

`val enum_bits : unit -> int BatEnum.t`
`val enum_int : int -> int BatEnum.t`
`val enum_bool : unit -> bool BatEnum.t`
`val enum_float : float -> float BatEnum.t`
`val enum_int32 : Stdlib.Int32.t -> Stdlib.Int32.t BatEnum.t`
`val enum_int64 : Stdlib.Int64.t -> Stdlib.Int64.t BatEnum.t`
`val enum_nativeint : Stdlib.Nativeint.t -> Stdlib.Nativeint.t BatEnum.t`
`val enum_char : unit -> char BatEnum.t`

## Working with data structures.

`val choice : 'a BatEnum.t -> 'a`

`choice e` returns a randomly-chosen element of `e`.

- raises `Empty`

  when applied to an empty enum. This function only works on finite enumerations with less than 230 elements.

`val multi_choice : int -> 'a BatEnum.t -> 'a BatEnum.t`

`multi_choice n e` returns an enumeration of `n` randomly-chosen elements of `e`.

`val shuffle : 'a BatEnum.t -> 'a array`

`shuffle e` returns a new array, containing the same set of elements as `e`, but in a random order.

Shuffling is implemented using the Fisher-Yates algorithm and works in O(n), where n is the number of elements of `e`.

This function only works on finite enumerations with less than 230 elements.

`val bits32 : unit -> Stdlib.Int32.t`

`Random.bits32 ()` returns 32 random bits as an integer between `Int32.min_int` and `Int32.max_int`.

- since 4.14.0

`val bits64 : unit -> Stdlib.Int64.t`

`Random.bits64 ()` returns 64 random bits as an integer between `Int64.min_int` and `Int64.max_int`.

- since 4.14.0

`val nativebits : unit -> Stdlib.Nativeint.t`

`Random.nativebits ()` returns 32 or 64 random bits (depending on the bit width of the platform) as an integer between `Nativeint.min_int` and `Nativeint.max_int`.

- since 4.14.0

## Advanced functions

`module State : sig ... end`

Manipulate the current state of the random generator.

`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.

`val split : unit -> State.t`

Draw a fresh PRNG state from the current state of the domain-local generator used by the default functions. (The state of the domain-local generator is modified.) See `Random.State.split`.

- since 3.6.0 and OCaml 5.0.0

`module Incubator : sig ... end`