type t = [ `Object | `PCG64 ] Obj.tval of_pyobject : Py.Object.t -> tval to_pyobject : [> tag ] Obj.t -> Py.Object.tval create : ?seed_seq:Py.Object.t -> unit -> tPCG64(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 ->
tadvance(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.tjumped(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 -> stringPrint the object to a human-readable representation.
val show : t -> stringPrint the object to a human-readable representation.
val pp : Format.formatter -> t -> unitPretty-print the object to a formatter.