package np

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type
type tag = [
  1. | `PCG64
]
type t = [ `Object | `PCG64 ] Obj.t
val of_pyobject : Py.Object.t -> t
val to_pyobject : [> tag ] Obj.t -> Py.Object.t
val create : ?seed_seq:Py.Object.t -> unit -> t

PCG64(seed_seq=None)

BitGenerator for the PCG-64 pseudo-random number generator.

Parameters ---------- seed : None, int, array_like[ints], SeedSequence, optional A seed to initialize the `BitGenerator`. If None, then fresh, unpredictable entropy will be pulled from the OS. If an ``int`` or ``array_likeints`` is passed, then it will be passed to `SeedSequence` to derive the initial `BitGenerator` state. One may also pass in a `SeedSequence` instance.

Notes ----- PCG-64 is a 128-bit implementation of O'Neill's permutation congruential generator (1_, 2_). PCG-64 has a period of :math:`2^

` and supports advancing an arbitrary number of steps as well as :math:`2^

` streams. The specific member of the PCG family that we use is PCG XSL RR 128/64 as described in the paper (2_).

``PCG64`` provides a capsule containing function pointers that produce doubles, and unsigned 32 and 64- bit integers. These are not directly consumable in Python and must be consumed by a ``Generator`` or similar object that supports low-level access.

Supports the method :meth:`advance` to advance the RNG an arbitrary number of steps. The state of the PCG-64 RNG is represented by 2 128-bit unsigned integers.

**State and Seeding**

The ``PCG64`` state vector consists of 2 unsigned 128-bit values, which are represented externally as Python ints. One is the state of the PRNG, which is advanced by a linear congruential generator (LCG). The second is a fixed odd increment used in the LCG.

The input seed is processed by `SeedSequence` to generate both values. The increment is not independently settable.

**Parallel Features**

The preferred way to use a BitGenerator in parallel applications is to use the `SeedSequence.spawn` method to obtain entropy values, and to use these to generate new BitGenerators:

>>> from numpy.random import Generator, PCG64, SeedSequence >>> sg = SeedSequence(1234) >>> rg = Generator(PCG64(s)) for s in sg.spawn(10)

**Compatibility Guarantee**

``PCG64`` makes a guarantee that a fixed seed and will always produce the same random integer stream.

References ---------- .. 1 `'PCG, A Family of Better Random Number Generators' <http://www.pcg-random.org/>`_ .. 2 O'Neill, Melissa E. `'PCG: A Family of Simple Fast Space-Efficient Statistically Good Algorithms for Random Number Generation' <https://www.cs.hmc.edu/tr/hmc-cs-2014-0905.pdf>`_

val advance : delta:[ `I of int | `Positive of Py.Object.t ] -> [> tag ] Obj.t -> t

advance(delta)

Advance the underlying RNG as-if delta draws have occurred.

Parameters ---------- delta : integer, positive Number of draws to advance the RNG. Must be less than the size state variable in the underlying RNG.

Returns ------- self : PCG64 RNG advanced delta steps

Notes ----- Advancing a RNG updates the underlying RNG state as-if a given number of calls to the underlying RNG have been made. In general there is not a one-to-one relationship between the number output random values from a particular distribution and the number of draws from the core RNG. This occurs for two reasons:

* The random values are simulated using a rejection-based method and so, on average, more than one value from the underlying RNG is required to generate an single draw. * The number of bits required to generate a simulated value differs from the number of bits generated by the underlying RNG. For example, two 16-bit integer values can be simulated from a single draw of a 32-bit RNG.

Advancing the RNG state resets any pre-computed random numbers. This is required to ensure exact reproducibility.

val jumped : ?jumps:[ `I of int | `Positive of Py.Object.t ] -> [> tag ] Obj.t -> Py.Object.t

jumped(jumps=1)

Returns a new bit generator with the state jumped.

Jumps the state as-if jumps * 210306068529402873165736369884012333109 random numbers have been generated.

Parameters ---------- jumps : integer, positive Number of times to jump the state of the bit generator returned

Returns ------- bit_generator : PCG64 New instance of generator jumped iter times

Notes ----- The step size is phi-1 when multiplied by 2**128 where phi is the golden ratio.

val to_string : t -> string

Print the object to a human-readable representation.

val show : t -> string

Print the object to a human-readable representation.

val pp : Format.formatter -> t -> unit

Pretty-print the object to a formatter.

OCaml

Innovation. Community. Security.