Struct qmc::sse::fast_ops::FastOpsTemplate

pub struct FastOpsTemplate<O: Op, ALLOC: FastOpAllocator = DefaultFastOpAllocator> { /* fields omitted */ }

A fast op container.

Implementations

impl<O: Op + Clone, ALLOC: FastOpAllocator> FastOpsTemplate<O, ALLOC>

pub fn new_from_nvars_and_nbonds_and_alloc(
    nvars: usize,
    nbonds: Option<usize>,
    alloc: ALLOC
) -> Self

A new manager which can handle nvars and is optimized for nbonds, will allocate memory using the given allocator.

pub fn new_from_nvars_and_nbonds(nvars: usize, nbonds: Option<usize>) -> Self

A new manager which can handle nvars and is optimized for nbonds.

pub fn new_from_nvars(nvars: usize) -> Self

New manager which can handle nvars

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

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

Trait Implementations

impl<O: Clone + Op, ALLOC: Clone + FastOpAllocator> Clone for FastOpsTemplate<O, ALLOC>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O: Op + Clone, ALLOC: FastOpAllocator> ClusterUpdater for FastOpsTemplate<O, ALLOC>

fn flip_each_cluster_ising_symmetry_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. Use this version if there’s ising symmetry in your graph.

fn flip_each_cluster_rng<R: Rng, F>(
    &mut self,
    prob: f64,
    rng: &mut R,
    state: &mut [bool],
    weight_change_on_global_flip: Option<F>
) where
    F: Fn(&Self::Node) -> f64, 

Flip each cluster in the graph using an rng instance, add to state changes in acc. You can provide a function to adjust the weights for flipping each cluster based off the nodes within it. Edges of the cluster will always be constant ops but the total weight change inside the cluster will affect the probability of acceptance (multiplied by a global prob for each cluster). This function should take a node reference and return the ratio of the new weight divided by old weight if a global spin flip were to take place.

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

Find a site with a constant op.

fn post_cluster_update_hook(&mut self)

Called after an update.

impl<O: Debug + Op, ALLOC: Debug + FastOpAllocator> Debug for FastOpsTemplate<O, ALLOC>

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

Formats the value using the given formatter.

impl<O: Op, ALLOC: FastOpAllocator> DebugOps for FastOpsTemplate<O, ALLOC>

fn count_diagonal_and_off(&self) -> (usize, usize)

Count the number of diagonal and offdiagonal ops. Sum is self.get_n()

fn count_constant_ops(&self) -> usize

Count the number of constant ops.

impl<O: Op + Clone, ALLOC: FastOpAllocator> DiagonalSubsection for FastOpsTemplate<O, ALLOC>

type Args = FastOpMutateArgs

The type required for mutating p values.

fn mutate_p<T, F>(
    &mut self,
    f: F,
    p: usize,
    t: T,
    args: Self::Args
) -> (T, Self::Args) where
    F: Fn(&Self, Option<&Self::Op>, T) -> (Option<Option<Self::Op>>, T), 

Mutate a single p value.

fn mutate_subsection<T, F>(
    &mut self,
    pstart: usize,
    pend: usize,
    t: T,
    f: F,
    args: Option<Self::Args>
) -> T where
    F: Fn(&Self, Option<&Self::Op>, T) -> (Option<Option<Self::Op>>, T), 

Mutate using a restricted prange and args. Allows for running on smaller subsections of the variables.

fn mutate_subsection_ops<T, F>(
    &mut self,
    pstart: usize,
    pend: usize,
    t: T,
    f: F,
    args: Option<Self::Args>
) -> T where
    F: Fn(&Self, &Self::Op, usize, T) -> (Option<Option<Self::Op>>, T), 

Mutate ops using a restricted prange and args. Allows for running on smaller subsections of the variables.

fn get_empty_args(
    &mut self,
    vars: SubvarAccess<'_, FastOpMutateArgs>
) -> FastOpMutateArgs

Get empty args for a subsection of variables, or from an existing set of args (does not clear).

fn fill_args_at_p(&self, p: usize, empty_args: Self::Args) -> Self::Args

Get the args required for mutation.

fn fill_args_at_p_with_hint<It>(
    &self,
    p: usize,
    args: &mut Self::Args,
    vars: &[usize],
    hint: It
) where
    It: IntoIterator<Item = Option<usize>>, 

Use a list of ps to make args. Hint provides up to one ps per var in order.

fn return_args(&mut self, args: Self::Args)

Returns arg made for the mutation

fn get_propagated_substate_with_hint<It>(
    &self,
    p: usize,
    substate: &mut [bool],
    state: &[bool],
    vars: &[usize],
    hint: It
) where
    It: IntoIterator<Item = Option<usize>>, 

Get the substate at p using ps to set values. Hint provides up to one ps per var in order. substate should start in p=0 configuration.

fn iter_ops_above_p<T, F, G>(&self, p: usize, t: T, f: F, f_at_p: G) -> T where
    F: Fn(usize, &Self::Node, T) -> (T, bool),
    G: Fn(&Self::Node, T) -> (T, bool), 

Iterate over ops at indices less than or equal to p. Applies function f_at_p only to the op at p. Applies f to all other ops above p.

impl<O: Op + Clone, ALLOC: FastOpAllocator> DiagonalUpdater for FastOpsTemplate<O, ALLOC>

fn mutate_ps<F, T>(&mut self, pstart: usize, pend: 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 mutate_ops<F, T>(&mut self, pstart: usize, pend: usize, t: T, f: F) -> T where
    F: Fn(&Self, &Self::Op, usize, T) -> (Option<Option<Self::Op>>, T), 

Mutate only the ops. Override with more efficient solutions if needed.

fn try_iterate_ps<F, T, V>(
    &self,
    pstart: usize,
    pend: usize,
    t: T,
    f: F
) -> Result<T, V> where
    F: Fn(&Self, Option<&Self::Op>, T) -> Result<T, V>, 

Iterate through the ops and call f. Exit early with Err(v).

fn try_iterate_ops<F, T, V>(
    &self,
    pstart: usize,
    pend: usize,
    t: T,
    f: F
) -> Result<T, V> where
    F: Fn(&Self, &Self::Op, usize, T) -> Result<T, V>, 

Iterate through ops only. Can override with more efficient implementation.

fn iterate_ps<F, T>(&self, pstart: usize, pend: usize, 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, pstart: usize, pend: usize, t: T, f: F) -> T where
    F: Fn(&Self, &Self::Op, usize, T) -> T, 

Iterate through ops only. Calls try_iterate_ops by default.

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

Perform a diagonal update step with thread rng.

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

Perform a diagonal update step.

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

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, ALLOC: FastOpAllocator> Factory<BinaryHeap<Reverse<usize>>> for FastOpsTemplate<O, ALLOC>

fn get_instance(&mut self) -> BinaryHeap<Reverse<usize>>

Get an instance of T

fn return_instance(&mut self, t: BinaryHeap<Reverse<usize>>)

Return an instance of T

impl<O: Op + Clone, ALLOC: FastOpAllocator> Factory<BondContainer<VarPos>> for FastOpsTemplate<O, ALLOC>

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

Get an instance of T

fn return_instance(&mut self, t: BondContainer<VarPos>)

Return an instance of T

impl<O: Op + Clone, ALLOC: FastOpAllocator> Factory<BondContainer<usize>> for FastOpsTemplate<O, ALLOC>

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<O: Op + Clone, ALLOC: FastOpAllocator> Factory<Vec<(usize, OpSide), Global>> for FastOpsTemplate<O, ALLOC>

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

Get an instance of T

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

Return an instance of T

impl<O: Op + Clone, ALLOC: FastOpAllocator> Factory<Vec<OpSide, Global>> for FastOpsTemplate<O, ALLOC>

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

Get an instance of T

fn return_instance(&mut self, t: Vec<OpSide>)

Return an instance of T

impl<O: Op + Clone, ALLOC: FastOpAllocator> Factory<Vec<Option<usize>, Global>> for FastOpsTemplate<O, ALLOC>

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

Get an instance of T

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

Return an instance of T

impl<O: Op + Clone, ALLOC: FastOpAllocator> Factory<Vec<bool, Global>> for FastOpsTemplate<O, ALLOC>

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<O: Op + Clone, ALLOC: FastOpAllocator> Factory<Vec<f64, Global>> for FastOpsTemplate<O, ALLOC>

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

Get an instance of T

fn return_instance(&mut self, t: Vec<f64>)

Return an instance of T

impl<O: Op + Clone, ALLOC: FastOpAllocator> Factory<Vec<usize, Global>> for FastOpsTemplate<O, ALLOC>

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<O: Op + Clone, ALLOC: FastOpAllocator> HeatBathDiagonalUpdater for FastOpsTemplate<O, ALLOC>

fn make_heatbath_diagonal_update<'b, H: Hamiltonian<'b>>(
    &mut self,
    cutoff: usize,
    beta: f64,
    state: &[bool],
    hamiltonian: &H,
    bond_weights: &BondWeights
)

Perform a single heatbath update.

fn make_heatbath_diagonal_update_with_rng<'b, H: Hamiltonian<'b>, R: Rng>(
    &mut self,
    cutoff: usize,
    beta: f64,
    state: &[bool],
    hamiltonian: &H,
    bond_weights: &BondWeights,
    rng: &mut R
)

Perform a single heatbath update.

fn make_heatbath_diagonal_update_with_rng_and_state_ref<'b, H: Hamiltonian<'b>, R: Rng>(
    &mut self,
    cutoff: usize,
    beta: f64,
    state: &mut [bool],
    hamiltonian: &H,
    bond_weights: &BondWeights,
    rng: &mut R
)

Perform a single heatbath update.

fn make_bond_weights<'b, H, E>(
    hamiltonian: H,
    num_bonds: usize,
    bonds_fn: E
) -> BondWeights where
    H: Fn(&[usize], usize, &[bool], &[bool]) -> f64,
    E: Fn(usize) -> &'b [usize], 

Make the bond weights struct for this container.

fn heat_bath_single_diagonal_update<'b, H: Hamiltonian<'b>, R: Rng>(
    op: Option<&Self::Op>,
    cutoff: usize,
    n: usize,
    beta: f64,
    state: &mut [bool],
    hamiltonian_and_weights: (&H, &BondWeights),
    rng: &mut R
) -> Option<Option<Self::Op>>

Perform a single heatbath update.

impl<O: Op, ALLOC: FastOpAllocator> IsingManager for FastOpsTemplate<O, ALLOC>

impl<O: Op + Clone, ALLOC: FastOpAllocator> LoopUpdater for FastOpsTemplate<O, ALLOC>

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<PRel>

Get the first p occupied which covers variable var, also returns the relative index.

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

Get the last p occupied which covers variable var, also returns the relative index.

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,
    relvar: usize,
    node: &Self::Node
) -> Option<PRel>

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

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

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

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

Get the nth occupied p.

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

Get the previous p for a given var.

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

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.

fn post_loop_update_hook(&mut self)

Called after an update.

impl<O: Op + Clone, ALLOC: FastOpAllocator> OpContainer for FastOpsTemplate<O, ALLOC>

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 get_count(&self, bond: usize) -> usize

Gets the count of bond ops in the graph.

fn itime_fold<F, T>(&self, state: &mut [bool], fold_fn: F, init: T) -> T where
    F: Fn(T, &[bool]) -> T, 

Iterate through the imaginary time states of the opcontainer.

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

Verify the integrity of the OpContainer.

impl<O: Op + Clone, ALLOC: FastOpAllocator> OpContainerConstructor for FastOpsTemplate<O, ALLOC>

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.

impl<O: Op, ALLOC: FastOpAllocator> QmcManager for FastOpsTemplate<O, ALLOC>

impl<O: Op + Clone, ALLOC: FastOpAllocator> RvbUpdater for FastOpsTemplate<O, ALLOC>

fn constant_ops_on_var(&self, var: usize, ps: &mut Vec<usize>)

Fill ps with the p values of constant (Hij=k) ops for a given var. An implementation by the same name is provided for LoopUpdaters

fn spin_flips_on_var(&self, var: usize, ps: &mut Vec<usize>)

Fill ps with the p values of spin flips for a given var. An implementation by the same name is provided for LoopUpdaters

fn rvb_update<R: Rng, EN: EdgeNavigator, H>(
    &mut self,
    edges: &EN,
    state: &mut [bool],
    updates: usize,
    diagonal_edge_hamiltonian: H,
    rng: &mut R
) -> usize where
    H: Fn(usize, bool, bool) -> f64, 

Perform a resonating bond update. edges lists all the 2-site bonds which define the lattice. state is the propagated state at time 0. updates is the number of updated to perform. diagonal_edge_hamiltonian gives the weight of a diagonal edge given a spin state. rng prng instance to use.

fn rvb_update_with_ising_weight<R: Rng, EN: EdgeNavigator, H, F>(
    &mut self,
    edges: &EN,
    state: &mut [bool],
    updates: usize,
    diagonal_edge_hamiltonian: H,
    ising_ratio: F,
    rng: &mut R
) -> usize where
    H: Fn(usize, bool, bool) -> f64,
    F: Fn(&Self::Op) -> f64, 

Perform a resonating bond update. edges lists all the 2-site bonds which define the lattice. state is the propagated state at time 0. updates is the number of updated to perform. diagonal_edge_hamiltonian gives the weight of a diagonal edge given a spin state. ising_ratio provides the weight ratio of a node after a global ising flip to current. rng prng instance to use.