Struct tiamat::Pcg

pub struct Pcg { /* fields omitted */ }

A Permuted Congruential Generator.

Permuted congruential generators (PCGs) are linear congruential generators that, instead of using their state as the random number, permute their state. This improves their statistical quality significantly, while maintaining quite fast performance; they are however not cryptographically secure.

The main interface for this struct are its Rng and SeedableRng implementations. In addition, Pcg also provides functions for advancing and reversing itself by an arbitrary amount of steps quickly.

Pcg provides for 2⁶³ different sequences, these are specified by the second field of the seed (see reseed's documentation). It implements the "xsh-rr-64-32" scheme.

For more information on PCGs, see pcgrandom.org.

Methods

impl Pcg

pub fn new(seed: u64, sequence: u64) -> Pcg

Creates the Pcg with a given seed and sequence.

The highest bit of sequence is ignored.

pub fn advance(&mut self, delta: u64)

Advances the Pcg by delta steps.

This uses a method similar to fast exponentiation and thus runs in O(log(delta)) time.

pub fn revert(&mut self, delta: u64)

Reverses the Pcg by delta steps.

This is a convenience method, reversing by delta steps is the same as advancing by 2⁶⁴-delta steps.

pub fn steps_since(&self, other: &Pcg) -> Option<u64>

Calculates the distance between Pcgs of the same sequence.

Errors

If self and other are on different streams, this method returns None.

Trait Implementations

impl Debug for Pcg

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Clone for Pcg

fn clone(&self) -> Pcg

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PartialEq for Pcg

fn eq(&self, other: &Pcg) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Pcg) -> bool

This method tests for !=.

impl Eq for Pcg

impl RandomGen for Pcg

fn gen_u32(&mut self) -> u32

Returns a (pseudo-)random, uniformly distributed u32.

fn gen<R: Random>(&mut self) -> R where     Self: Sized,

Generates a random value.

fn build<B, R>(&mut self, builder: &B) -> R where     B: BuildRandom<R>,     Self: Sized,

Generates a random value according to some specification.

fn choose_from<'a, T>(&mut self, xs: &'a [T]) -> &'a T where     Self: Sized,

Chooses a random element from the slice, where each element has the same probability of being chosen.

Important traits for IterGen<'a, G, R>

impl<'a, G: 'a, R: 'a> Iterator for IterGen<'a, G, R> where
    G: RandomGen,
    R: Random,  type Item = R;

fn iter_gen<R: Random>(&mut self) -> IterGen<Self, R> where     Self: Sized,

Returns an iterator over randomly generated values.

Important traits for IterBuild<'a, G, B, R>

impl<'a, G: 'a, B: 'a, R> Iterator for IterBuild<'a, G, B, R> where
    G: RandomGen,
    B: BuildRandom<R>,  type Item = R;

fn iter_build<'a, B: 'a, R>(     &'a mut self,     builder: &'a B ) -> IterBuild<'a, Self, B, R> where     B: BuildRandom<R>,     Self: Sized,

Returns an iterator over randomly built values.

Important traits for IterChooseFrom<'a, G, T>

impl<'a, G: 'a, T: 'a> Iterator for IterChooseFrom<'a, G, T> where
    G: RandomGen,  type Item = &'a T;

fn iter_choose_from<'a, T>(     &'a mut self,     xs: &'a [T] ) -> IterChooseFrom<'a, Self, T> where     Self: Sized,

Returns an iterator over values randomly chosen from a slice.

fn gen_u64(&mut self) -> u64

Returns a (pseudo-)random, uniformly distributed u64.

fn fill_buffer(&mut self, buffer: &mut [u8])

Fills the buffer with (pseudo-)random bytes.

impl Random for Pcg

fn random<G: RandomGen>(rng: &mut G) -> Pcg

Randomly generates a value.