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.



OCamldoc                          2024-05-31                   Random.State(3)