Struct 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) -> Self

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 previous 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 occurred in a row

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

Trait Implementations

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

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> Debug for CoinFlipSequence<R>

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

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<Self, __D::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>)

Only implemented for testcases

Default implementation would suffice

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

where AccFn: FnMut(&Self, &CoinFlipMove, &mut Acc),

Only implemented for testcases

Default implementation would suffice

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

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-stateif 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 statefor 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) -> S

where 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::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.