Struct lattice_qcd_rs::simulation::monte_carlo::metropolis_hastings_sweep::MetropolisHastingsSweep

pub struct MetropolisHastingsSweep<Rng: Rng> { /* private fields */ }

Metropolis Hastings method by doing a pass on all points

Example

use lattice_qcd_rs::error::ImplementationError;
use lattice_qcd_rs::simulation::{LatticeState, LatticeStateDefault, MetropolisHastingsSweep};
use rand::SeedableRng;

let rng = rand::rngs::StdRng::seed_from_u64(0); // change with your seed
let mut mh = MetropolisHastingsSweep::new(1, 0.1_f64, rng)
    .ok_or(ImplementationError::OptionWithUnexpectedNone)?;
// Realistically you want more steps than 10

let mut state = LatticeStateDefault::<3>::new_cold(1_f64, 6_f64, 4)?;
for _ in 0..10 {
    state = state.monte_carlo_step(&mut mh)?;
    println!(
        "mean probability of acceptance during last step {} and replaced {} links",
        mh.prob_replace_mean(),
        mh.number_replace_last()
    );
    // operation to track the progress or the evolution
}
// operation at the end of the simulation

Implementations

impl<Rng: Rng> MetropolisHastingsSweep<Rng>

pub const fn rng(&self) -> &Rng

Get a ref to the rng.

pub fn new(number_of_update: usize, spread: Real, rng: Rng) -> Option<Self>

spread should be between 0 and 1 both not included and number_of_update should be greater than 0.

number_of_update is the number of times a link matrix is randomly changed. spread is the spread factor for the random matrix change ( used in su3::random_su3_close_to_unity).

pub const fn prob_replace_mean(&self) -> Real

Get the mean of last probably of acceptance of the random change.

pub const fn number_replace_last(&self) -> usize

Number of accepted change during last sweep

pub fn rng_owned(self) -> Rng

Get the last probably of acceptance of the random change.

pub fn rng_mut(&mut self) -> &mut Rng

Get a mutable reference to the rng.

Trait Implementations

impl<Rng: Rng> AsMut<Rng> for MetropolisHastingsSweep<Rng>

fn as_mut(&mut self) -> &mut Rng

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

impl<Rng: Rng> AsRef<Rng> for MetropolisHastingsSweep<Rng>

fn as_ref(&self) -> &Rng

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

impl<Rng: Clone + Rng> Clone for MetropolisHastingsSweep<Rng>

fn clone(&self) -> MetropolisHastingsSweep<Rng>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Rng: Debug + Rng> Debug for MetropolisHastingsSweep<Rng>

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

Formats the value using the given formatter.

impl<'de, Rng> Deserialize<'de> for MetropolisHastingsSweep<Rng>where Rng: Deserialize<'de> + Rng,

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

Deserialize this value from the given Serde deserializer.

impl<Rng, const D: usize> MonteCarlo<LatticeStateDefault<D>, D> for MetropolisHastingsSweep<Rng>where Rng: Rng,

type Error = Never

Error returned while getting the next element.

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

Do one Monte Carlo simulation step.

impl<Rng: PartialEq + Rng> PartialEq<MetropolisHastingsSweep<Rng>> for MetropolisHastingsSweep<Rng>

fn eq(&self, other: &MetropolisHastingsSweep<Rng>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<Rng> Serialize for MetropolisHastingsSweep<Rng>where Rng: Serialize + Rng,

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

Serialize this value into the given Serde serializer.

impl<Rng: Rng> StructuralPartialEq for MetropolisHastingsSweep<Rng>