Struct Metropolis 

pub struct Metropolis<S, R>
where
    S: State,
    R: Rng,
{
    pub state: S,
    pub params: <S as State>::Params,
    pub beta: f64,
    pub steps: usize,
    pub accepted_moves: usize,
    pub rng: R,
}

Fields

state: S

params: <S as State>::Params

beta: f64

steps: usize

accepted_moves: usize

rng: R

Implementations

impl<S> Metropolis<S, ThreadRng>

where S: State + Default, <S as State>::Params: Default,

pub fn with_steps(beta: f64, steps: usize) -> Metropolis<S, ThreadRng>

pub fn with_steps_no_beta(steps: usize) -> Metropolis<S, ThreadRng>

impl<S> Metropolis<S, ThreadRng>

where S: State, <S as State>::Params: Default,

pub fn with_state(state: S, beta: f64, steps: usize) -> Metropolis<S, ThreadRng>

pub fn with_state_no_beta(state: S, steps: usize) -> Metropolis<S, ThreadRng>

impl<S> Metropolis<S, ThreadRng>

where S: State,

pub fn with_state_params( state: S, params: <S as State>::Params, beta: f64, steps: usize, ) -> Metropolis<S, ThreadRng>

pub fn with_state_params_no_beta( state: S, params: <S as State>::Params, steps: usize, ) -> Metropolis<S, ThreadRng>

impl<S, R> Metropolis<S, R>

where S: State, <S as State>::Params: Default, R: Rng,

pub fn with_state_rng( state: S, beta: f64, steps: usize, rng: R, ) -> Metropolis<S, R>

pub fn with_state_rng_no_beta( state: S, steps: usize, rng: R, ) -> Metropolis<S, R>

impl<S, R> Metropolis<S, R>

where S: State + Default, <S as State>::Params: Default, R: Rng,

pub fn with_rng(beta: f64, steps: usize, rng: R) -> Metropolis<S, R>

pub fn with_rng_no_beta(steps: usize, rng: R) -> Metropolis<S, R>

impl<S, R> Metropolis<S, R>

where S: State, R: Rng,

pub fn with_all( state: S, params: <S as State>::Params, beta: f64, steps: usize, rng: R, ) -> Metropolis<S, R>

pub fn with_all_no_beta( state: S, params: <S as State>::Params, steps: usize, rng: R, ) -> Metropolis<S, R>

pub fn step(&mut self)

Metropolis algorithm

pub fn run_empty(&mut self)

pub fn run_with<O>(&mut self) -> Vec<<O as Observer<S>>::Observation>

where O: Observer<S>,

pub fn run_with_2<O1, O2>( &mut self, ) -> (Vec<<O1 as Observer<S>>::Observation>, Vec<<O2 as Observer<S>>::Observation>)

where O1: Observer<S>, O2: Observer<S>,

pub fn run_with_3<O1, O2, O3>( &mut self, ) -> (Vec<<O1 as Observer<S>>::Observation>, Vec<<O2 as Observer<S>>::Observation>, Vec<<O3 as Observer<S>>::Observation>)

where O1: Observer<S>, O2: Observer<S>, O3: Observer<S>,

pub fn run_with_4<O1, O2, O3, O4>( &mut self, ) -> (Vec<<O1 as Observer<S>>::Observation>, Vec<<O2 as Observer<S>>::Observation>, Vec<<O3 as Observer<S>>::Observation>, Vec<<O4 as Observer<S>>::Observation>)

where O1: Observer<S>, O2: Observer<S>, O3: Observer<S>, O4: Observer<S>,

pub fn run_with_n<Obs>( &mut self, obs: Vec<Box<dyn DynObserver<S, Observation = Obs>>>, ) -> Vec<Vec<Obs>>

Makes a run for a vec of observers All observers needs to have the same Observation type And need to be dyn-capable All Observers are made dyn using DynObserver

pub fn accepted_rate(&self) -> f64

pub fn rejected_rate(&self) -> f64