Struct lattice_qcd_rs::simulation::monte_carlo::hybrid::HybridMethodVec

pub struct HybridMethodVec<'a, State, E, const D: usize>where
    State: LatticeState<D>,{ /* private fields */ }

hybrid method that combine multiple methods. It requires that all methods return the same error. You can use AdaptorMethodError to convert the error. If you want type with different error you can use HybridMethodCouple.

Example

see level module example super.

Implementations

impl<'a, State, E, const D: usize> HybridMethodVec<'a, State, E, D>where State: LatticeState<D>,

pub fn methods(&self) -> &Vec<&'a mut dyn MonteCarlo<State, D, Error = E>>

get the methods

pub fn new_empty() -> Self

Create an empty Self.

pub fn with_capacity(capacity: usize) -> Self

Create an empty Self where the vector is preallocated for capacity element.

pub fn new(methods: Vec<&'a mut dyn MonteCarlo<State, D, Error = E>>) -> Self

Create a new Self from a list of MonteCarlo

pub fn methods_mut( &mut self ) -> &mut Vec<&'a mut dyn MonteCarlo<State, D, Error = E>>

Get a mutable reference to the methods used,

pub fn push_method( &mut self, mc_ref: &'a mut dyn MonteCarlo<State, D, Error = E> )

Add a method at the end.

pub fn pop_method( &mut self ) -> Option<&'a mut dyn MonteCarlo<State, D, Error = E>>

Remove a method at the end an returns it. Return None if the methods is empty.

pub fn len(&self) -> usize

Get the number of methods

pub fn is_empty(&self) -> bool

Return wether the number is zero.

Trait Implementations

impl<'a, State, E, const D: usize> AsMut<Vec<&'a mut (dyn MonteCarlo<State, D, Error = E> + 'a), Global>> for HybridMethodVec<'a, State, E, D>where State: LatticeState<D>,

fn as_mut(&mut self) -> &mut Vec<&'a mut dyn MonteCarlo<State, D, Error = E>>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<'a, State, E, const D: usize> AsRef<Vec<&'a mut (dyn MonteCarlo<State, D, Error = E> + 'a), Global>> for HybridMethodVec<'a, State, E, D>where State: LatticeState<D>,

fn as_ref(&self) -> &Vec<&'a mut dyn MonteCarlo<State, D, Error = E>>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, State, E, const D: usize> Default for HybridMethodVec<'a, State, E, D>where State: LatticeState<D>,

fn default() -> Self

Returns the “default value” for a type.

impl<'a, State, E, const D: usize> MonteCarlo<State, D> for HybridMethodVec<'a, State, E, D>where State: LatticeState<D>,

type Error = HybridMethodVecError<E>

Error returned while getting the next element.

fn next_element(&mut self, state: State) -> Result<State, Self::Error>

Do one Monte Carlo simulation step.