Struct qmc::sse::fast_ops::FastOpsTemplate

pub struct FastOpsTemplate<O: Op> { /* fields omitted */ }

A fast op container.

Implementations

impl<O: Op + Clone> FastOpsTemplate<O>

pub fn new_from_ops<I: Iterator<Item = (usize, O)>>(
    nvars: usize,
    ps_and_ops: I
) -> Self

Make a new Manager from an interator of ops, and number of variables.

Trait Implementations

impl<O: Op + Clone> ClassicalLoopUpdater for FastOpsTemplate<O>

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

Check if variable is ever flipped by an offdiagonal op.

fn get_var_alloc(&mut self, nvars: usize) -> Vec<bool>

Get the allocation.

fn return_var_alloc(&mut self, alloc: Vec<bool>)

Return the allocation.

fn get_boundary_alloc(&mut self) -> Vec<(usize, bool)>

Get the allocation.

fn return_boundary_alloc(&mut self, alloc: Vec<(usize, bool)>)

Return the allocation.

fn get_sat_alloc(&mut self) -> HashSampler<usize>

Get the allocation

fn get_broken_alloc(&mut self) -> HashSampler<usize>

Get the allocation

fn return_sat_alloc(&mut self, alloc: HashSampler<usize>)

Return the allocation.

fn return_broken_alloc(&mut self, alloc: HashSampler<usize>)

Return the allocation.

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

Perform an update, return size of cluster.

fn post_semiclassical_update_hook(&mut self)

Called after an update.

impl<O: Clone + Op> Clone for FastOpsTemplate<O>

fn clone(&self) -> FastOpsTemplate<O>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O: Op + Clone> ClusterUpdater for FastOpsTemplate<O>

fn get_frontier_alloc(&mut self) -> Vec<(usize, OpSide)>

Get an allocation for the frontier.

fn get_interior_frontier_alloc(&mut self) -> Vec<(usize, (usize, OpSide))>

Get an allocation for the interior frontier.

fn get_boundaries_alloc(
    &mut self,
    size: usize
) -> Vec<(Option<usize>, Option<usize>)>

Get an allocation for the bounaries.

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

Get an allocation for the spin flips.

fn return_frontier_alloc(&mut self, frontier: Vec<(usize, OpSide)>)

Return an alloc.

fn return_interior_frontier_alloc(
    &mut self,
    interior_frontier: Vec<(usize, (usize, OpSide))>
)

Return an alloc.

fn return_boundaries_alloc(
    &mut self,
    boundaries: Vec<(Option<usize>, Option<usize>)>
)

Return an alloc.

fn return_flip_alloc(&mut self, flips: Vec<bool>)

Return an alloc.

fn post_cluster_update_hook(&mut self)

Called after an update.

fn flip_each_cluster_rng<R: Rng>(
    &mut self,
    prob: f64,
    rng: &mut R,
    state: &mut [bool]
)

Flip each cluster in the graph using an rng instance, add to state changes in acc.

fn find_constant_op(&self) -> Option<usize>

Find a site with a constant op.

impl<O: Debug + Op> Debug for FastOpsTemplate<O>

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

Formats the value using the given formatter.

impl<O: Op + Clone> DiagonalUpdater for FastOpsTemplate<O>

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 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<O: Op + Clone> LoopUpdater for FastOpsTemplate<O>

type Node = FastOpNodeTemplate<O>

The type used to contain the Op and handle movement around the worldlines.

fn get_node_ref(&self, p: usize) -> Option<&Self::Node>

Get a ref to a node at position p

fn get_node_mut(&mut self, p: usize) -> Option<&mut Self::Node>

Get a mutable ref to the node at position p

fn get_first_p(&self) -> Option<usize>

Get the first occupied p if it exists.

fn get_last_p(&self) -> Option<usize>

Get the last occupied p if it exists.

fn get_first_p_for_var(&self, var: usize) -> Option<usize>

Get the first p occupied which covers variable var.

fn get_last_p_for_var(&self, var: usize) -> Option<usize>

Get the last p occupied which covers variable var.

fn get_previous_p(&self, node: &Self::Node) -> Option<usize>

Get the previous occupied p compared to node.

fn get_next_p(&self, node: &Self::Node) -> Option<usize>

Get the next occupied p compared to node.

fn get_previous_p_for_rel_var(
    &self,
    revar: usize,
    node: &Self::Node
) -> Option<usize>

Get the previous p for a given var, takes the relative var index in node.

fn get_next_p_for_rel_var(
    &self,
    revar: usize,
    node: &Self::Node
) -> Option<usize>

Get the next p for a given var, takes the relative var index in node.

fn get_nth_p(&self, n: usize) -> usize

Get the nth occupied p.

fn get_leg_weight_alloc(&mut self) -> Vec<((usize, OpSide), f64)>

Allocation for leg buffer.

fn return_leg_weight_alloc(&mut self, alloc: Vec<((usize, OpSide), f64)>)

Return the allocation from get_leg_weight_alloc.

fn post_loop_update_hook(&mut self)

Called after an update.

fn get_previous_p_for_var(
    &self,
    var: usize,
    node: &Self::Node
) -> Result<Option<usize>, ()>

Get the previous p for a given var.

fn get_next_p_for_var(
    &self,
    var: usize,
    node: &Self::Node
) -> Result<Option<usize>, ()>

Get the next p for a given var.

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

Returns if a given variable is covered by any ops.

fn make_loop_update<H>(
    &mut self,
    initial_n: Option<usize>,
    hamiltonian: H,
    state: &mut [bool]
) where
    H: Fn(&[usize], usize, &[bool], &[bool]) -> f64, 

Make a loop update to the graph with thread rng.

fn make_loop_update_with_rng<H, R: Rng>(
    &mut self,
    initial_n: Option<usize>,
    hamiltonian: H,
    state: &mut [bool],
    rng: &mut R
) where
    H: Fn(&[usize], usize, &[bool], &[bool]) -> f64, 

Make a loop update to the graph.

impl<O: Op + Clone> OpContainer for FastOpsTemplate<O>

type Op = O

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<O: Op + Clone> OpContainerConstructor for FastOpsTemplate<O>

fn new(nvars: usize) -> Self

Make a new container for nvars.