Struct net_ensembles::sampling::examples::coin_flips::CoinFlipSequence

pub struct CoinFlipSequence<R> { /* private fields */ }

A sequence of Coin flips. Contains random Number generator

Implementations

impl<R> CoinFlipSequence<R>where
    R: Rng,

pub fn new(n: usize, rng: R) -> CoinFlipSequence<R>

Create new coin flip sequence

• length n
• use rng as random number generator

impl<R> CoinFlipSequence<R>

pub fn head_count(&self) -> usize

Count how often Head occurs in the Coin flip sequence

pub fn update_head_count(&self, step: &CoinFlipMove, head_count: &mut usize)

• Calculate the head count, if a previouse head count of the ensemble and the markov steps leading to the current state are known
• head_count is updated
• might panic if step was not the markov step leading from the ensemble with head_count to the current ensemble - if it does not panic, the result will be wrong

pub fn max_heads_in_a_row(&self) -> usize

Count many times Head occured in a row

• uses maximum value, i.e., for the sequence HHTHHHT it will return 3

Trait Implementations

impl<R> Clone for CoinFlipSequence<R>where
    R: Clone,

fn clone(&self) -> CoinFlipSequence<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R> Debug for CoinFlipSequence<R>where
    R: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de, R> Deserialize<'de> for CoinFlipSequence<R>where
    R: Deserialize<'de>,

fn deserialize<__D>(
    __deserializer: __D
) -> Result<CoinFlipSequence<R>, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R> HasRng<R> for CoinFlipSequence<R>where
    R: Rng,

fn rng(&mut self) -> &mut R

Access RNG

fn swap_rng(&mut self, rng: &mut R)

If you need to exchange the internal rng

impl<R> MarkovChain<CoinFlipMove, ()> for CoinFlipSequence<R>where
    R: Rng,

fn m_step(&mut self) -> CoinFlipMove

Perform a markov step

fn m_steps(&mut self, count: usize, steps: &mut Vec<CoinFlipMove, Global>)

Only implemented for testcases

Default implementation would suffice

fn m_steps_acc<Acc, AccFn>(
    &mut self,
    count: usize,
    steps: &mut Vec<CoinFlipMove, Global>,
    acc: &mut Acc,
    acc_fn: AccFn
)where
    AccFn: FnMut(&CoinFlipSequence<R>, &CoinFlipMove, &mut Acc),

Only implemented for testcases

Default implementation would suffice

fn undo_steps(&mut self, steps: &[CoinFlipMove], res: &mut Vec<(), Global>)

Only implemented for testcases

Default implementation would suffice

fn undo_steps_quiet(&mut self, steps: &[CoinFlipMove])

Only implemented for testcases

Default implementation would suffice

fn steps_accepted(&mut self, _steps: &[CoinFlipMove])

Only implemented for testcases

Default implementation would suffice

fn steps_rejected(&mut self, _steps: &[CoinFlipMove])

Only implemented for testcases

Default implementation would suffice

fn undo_step(&mut self, step: &CoinFlipMove)

undo a markov step, return result-state

if you want to undo more than one step see undo_steps

fn undo_step_quiet(&mut self, step: &CoinFlipMove)

undo a markov, panic on invalid result state

for undoing multiple steps see undo_steps_quiet

fn m_steps_quiet(&mut self, count: usize)

Markov steps without return

fn m_step_acc<Acc, AccFn>(&mut self, acc: &mut Acc, acc_fn: AccFn) -> Swhere
    AccFn: FnMut(&Self, &S, &mut Acc),

Accumulating markov step

fn m_steps_acc_quiet<Acc, AccFn>(
    &mut self,
    count: usize,
    acc: &mut Acc,
    acc_fn: AccFn
)where
    AccFn: FnMut(&Self, &S, &mut Acc),

Accumulating markov steps

impl<R> Serialize for CoinFlipSequence<R>where
    R: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.