Struct WindowEm

pub struct WindowEm<const D: usize, T> { /* private fields */ }

A runner of the window EM algorithm.

The window EM algorithm updates the SFS estimate in smaller blocks of data, leading to multiple updates to the estimate per full EM-step. These block estimates are averaged over a sliding window to smooth the global estimate. The algorithm can be configured to use different EM-like algorithms (corresponding to the parameter T) for each inner block update step.

Implementations

impl<const D: usize, T> WindowEm<D, T>

pub fn new(em: T, window: Window<D>, block_size: usize) -> Self

Returns a new instance of the runner.

The em is the inner kind of EM to handle the blocks, and the block_size is the number of sites per blocks. The provided window should match the shape of the input and SFS that is provided for inference later. Where no good prior guess for the SFS exists, using Window::from_zeros is recommended.

Trait Implementations

impl<const D: usize, T: Clone> Clone for WindowEm<D, T>

fn clone(&self) -> WindowEm<D, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const D: usize, T: Debug> Debug for WindowEm<D, T>

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

Formats the value using the given formatter.

impl<const D: usize, I, T> Em<D, I> for WindowEm<D, T>

where for<'a> &'a I: IntoBlockIterator<D>, for<'a> T: Em<D, <&'a I as IntoBlockIterator<D>>::Item>,

fn e_step(&mut self, sfs: Sfs<D>, input: &I) -> (Self::Status, USfs<D>)

The E-step of the algorithm.

fn em_step(&mut self, sfs: Sfs<N>, input: &I) -> (Self::Status, Sfs<N>)

A full EM-step of the algorithm.

fn em<S>( &mut self, sfs: Sfs<N>, input: &I, stopping_rule: S, ) -> (Self::Status, Sfs<N>)

where S: Stop<Self, Status = Self::Status>,

Runs the EM algorithm until convergence.

impl<const D: usize, T> EmStep for WindowEm<D, T>

where T: EmStep,

type Status = Vec<<T as EmStep>::Status>

The status returned after each step.

fn inspect<const N: usize, F>(self, f: F) -> Inspect<Self, F>

where F: FnMut(&Self, &Self::Status, &USfs<N>),

Inspect the status after each E-step.

impl<const D: usize, T: PartialEq> PartialEq for WindowEm<D, T>

fn eq(&self, other: &WindowEm<D, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const D: usize, R, T> StreamingEm<D, R> for WindowEm<D, T>

where R: Rewind, R::Site: EmSite<D>, for<'a> T: StreamingEm<D, Take<Enumerate<&'a mut R>>>,

fn stream_e_step( &mut self, sfs: Sfs<D>, reader: &mut R, ) -> Result<(Self::Status, USfs<D>)>

The E-step of the algorithm.

fn stream_em_step( &mut self, sfs: Sfs<D>, reader: &mut R, ) -> Result<(Self::Status, Sfs<D>)>

A full EM-step of the algorithm.

fn stream_em<S>( &mut self, sfs: Sfs<D>, reader: &mut R, stopping_rule: S, ) -> Result<(Self::Status, Sfs<D>)>

where S: Stop<Self, Status = Self::Status>,

Runs the EM algorithm until convergence.

impl<const D: usize, T> StructuralPartialEq for WindowEm<D, T>