Struct qmc::sse::simple_ops::SimpleOpDiagonal

pub struct SimpleOpDiagonal { /* fields omitted */ }

A simple implementation of a diagonal op container.

Implementations

impl SimpleOpDiagonal

pub fn debug_print<H>(&self, h: H) where
    H: Fn(&[usize], usize, &[bool], &[bool]) -> f64, 

Debug print the container.

pub fn set_pth(&mut self, p: usize, op: Option<SimpleOp>) -> Option<SimpleOp>

Set the pth op.

Trait Implementations

impl ClassicalLoopUpdater for SimpleOpDiagonal

fn var_ever_flips(&self, var: usize) -> bool

Check if variable is ever flipped by an offdiagonal op.

fn run_semiclassical_edge_update<R: Rng, EN: EdgeNavigator>(
    &mut self,
    edges: &EN,
    state: &mut [bool],
    rng: R
) -> (usize, bool)

Perform an edge update, return size of cluster and whether it was flipped.

fn run_semiclassical_update<R: Rng, EN: EdgeNavigator, F>(
    &mut self,
    edges: &EN,
    bond_select: F,
    state: &mut [bool],
    rng: R
) -> (usize, bool) where
    F: Fn(&mut Self, &[bool], &mut [bool], &mut BondContainer<usize>, &mut BondContainer<usize>, &mut R) -> usize, 

Use a function bond_select to select a region of variables and the bordering bonds, then perform a semiclassical update on those variables by flipping them and rearranging ops on the bonds. The function bond_select must take the current state, a mutable array giving whether variables are in the cluster to be flipped, and two mutable BondContainers which should be filled with bonds on the border of the cluster which are broken or unbroken and of equal weight, then must return the size of the cluster. See run_semiclassical_edge_update for an implementation.

fn count_ops_on_border(
    &self,
    sat_set: &BondContainer<usize>,
    broken_set: &BondContainer<usize>
) -> (usize, usize)

Count the number of bonds on border which belong to set_set and broken_set.

fn post_semiclassical_update_hook(&mut self)

Called after an update.

impl Clone for SimpleOpDiagonal

fn clone(&self) -> SimpleOpDiagonal

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SimpleOpDiagonal

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

Formats the value using the given formatter.

impl DiagonalUpdater for SimpleOpDiagonal

fn mutate_ps<F, T>(&mut self, cutoff: usize, t: T, f: F) -> T where
    F: Fn(&Self, Option<&Self::Op>, T) -> (Option<Option<Self::Op>>, T), 

Folds across the p values, passing T down. Mutates op if returned values is Some(...)

fn iterate_ps<F, T>(&self, t: T, f: F) -> T where
    F: Fn(&Self, Option<&Self::Op>, T) -> T, 

Iterate through the ops and call f.

fn iterate_ops<F, T>(&self, t: T, f: F) -> T where
    F: Fn(&Self, &Self::Op, T) -> T, 

Iterate through ops only.

fn make_diagonal_update<'b, H, E>(
    &mut self,
    cutoff: usize,
    beta: f64,
    state: &[bool],
    hamiltonian: &Hamiltonian<'b, H, E>
) where
    H: Fn(&[usize], usize, &[bool], &[bool]) -> f64,
    E: Fn(usize) -> (&'b [usize], bool), 

Perform a diagonal update step with thread rng.

fn make_diagonal_update_with_rng<'b, H, E, R: Rng>(
    &mut self,
    cutoff: usize,
    beta: f64,
    state: &[bool],
    hamiltonian: &Hamiltonian<'b, H, E>,
    rng: &mut R
) where
    H: Fn(&[usize], usize, &[bool], &[bool]) -> f64,
    E: Fn(usize) -> (&'b [usize], bool), 

Perform a diagonal update step.

fn make_diagonal_update_with_rng_and_state_ref<'b, H, E, R: Rng>(
    &mut self,
    cutoff: usize,
    beta: f64,
    state: &mut [bool],
    hamiltonian: &Hamiltonian<'b, H, E>,
    rng: &mut R
) where
    H: Fn(&[usize], usize, &[bool], &[bool]) -> f64,
    E: Fn(usize) -> (&'b [usize], bool), 

Perform a diagonal update step using in place edits to state.

fn post_diagonal_update_hook(&mut self)

Called after an update.

impl Factory<BondContainer<usize>> for SimpleOpDiagonal

fn get_instance(&mut self) -> BondContainer<usize>

Get an instance of T

fn return_instance(&mut self, _t: BondContainer<usize>)

Return an instance of T

impl Factory<Vec<bool>> for SimpleOpDiagonal

fn get_instance(&mut self) -> Vec<bool>

Get an instance of T

fn return_instance(&mut self, _t: Vec<bool>)

Return an instance of T

impl Factory<Vec<usize>> for SimpleOpDiagonal

fn get_instance(&mut self) -> Vec<usize>

Get an instance of T

fn return_instance(&mut self, _t: Vec<usize>)

Return an instance of T

impl Into<SimpleOpDiagonal> for SimpleOpLooper

fn into(self) -> SimpleOpDiagonal

Performs the conversion.

impl Into<SimpleOpLooper> for SimpleOpDiagonal

fn into(self) -> SimpleOpLooper

Performs the conversion.

impl OpContainer for SimpleOpDiagonal

type Op = SimpleOp

The op object to manage.

fn get_cutoff(&self) -> usize

Get the cutoff for this container.

fn set_cutoff(&mut self, cutoff: usize)

Set the cutoff for this container.

fn get_n(&self) -> usize

Get the number of non-identity ops.

fn get_nvars(&self) -> usize

Get the number of managed variables.

fn get_pth(&self, p: usize) -> Option<&Self::Op>

Get the pth op, None is identity.

fn verify(&self, state: &[bool]) -> bool

Verify the integrity of the OpContainer.

impl OpContainerConstructor for SimpleOpDiagonal

fn new(nvars: usize) -> Self

Make a new container for nvars.

fn new_with_bonds(nvars: usize, _nbonds: usize) -> Self

Make a new container for nvars giving a hint as to the number of bonds.