Random.State(3) | OCaml library | Random.State(3) |

# NAME

Random.State - no description

# Module

Module Random.State

# Documentation

Module **State**

: **sig end**

*type t*

The type of PRNG states.

*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 random seed chosen in
a system-dependent way. The seed is obtained as described in
**Random.self_init** .

*val copy* : **t -> t**

Return a copy of the given state.

*val bits* : **t -> int**

*val int* : **t -> int -> int**

*val full_int* : **t -> int -> int**

*val int_in_range* : **t -> min:int -> max:int ->
int**

*val int32* : **t -> Int32.t -> Int32.t**

*val int32_in_range* : **t -> min:int32 -> max:int32
-> int32**

*val nativeint* : **t -> Nativeint.t ->
Nativeint.t**

*val nativeint_in_range* : **t -> min:nativeint ->
max:nativeint -> nativeint**

*val int64* : **t -> Int64.t -> Int64.t**

*val int64_in_range* : **t -> min:int64 -> max:int64
-> int64**

*val float* : **t -> float -> float**

*val bool* : **t -> bool**

*val bits32* : **t -> Int32.t**

*val bits64* : **t -> Int64.t**

*val nativebits* : **t -> Nativeint.t**

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 split* : **t -> t**

Draw a fresh PRNG state from the given PRNG state. (The given PRNG state is modified.) The new PRNG is statistically independent from the given PRNG. Data can be drawn from both PRNGs, in any order, without risk of correlation. Both PRNGs can be split later, arbitrarily many times.

**Since** 5.0

*val to_binary_string* : **t -> string**

Serializes the PRNG state into an immutable sequence of bytes. See
**Random.State.of_binary_string** for deserialization.

The **string** type is intended here for serialization only,
the encoding is not human-readable and may not be printable.

Note that the serialization format may differ across OCaml versions.

**Since** 5.1

*val of_binary_string* : **string -> t**

Deserializes a byte sequence obtained by calling
**Random.State.to_binary_string** . The resulting PRNG state will produce
the same random numbers as the state that was passed as input to
**Random.State.to_binary_string** .

**Since** 5.1

**Raises Failure** if the input is not in the expected
format.

Note that the serialization format may differ across OCaml versions.

Unlike the functions provided by the **Marshal** module, this
function either produces a valid state or fails cleanly with a
**Failure** exception. It can be safely used on user-provided, untrusted
inputs.

2024-05-31 | OCamldoc |