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>(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> Clone for FastOpsTemplate<O>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

pub 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.

pub 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.

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

Find a site with a constant op.

pub fn post_cluster_update_hook(&mut self)

Called after an update.

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

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

Formats the value using the given formatter.

impl<O: Op> DebugOps for FastOpsTemplate<O>

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

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

pub fn count_constant_ops(&self) -> usize

Count the number of constant ops.

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

type Args = FastOpMutateArgs

The type required for mutating p values.

pub 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.

pub 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.

pub 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.

pub 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).

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

Get the args required for mutation.

pub 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.

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

Returns arg made for the mutation

pub 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.

pub 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> DiagonalUpdater for FastOpsTemplate<O>

pub 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(...)

pub 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.

pub 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).

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub fn post_diagonal_update_hook(&mut self)

Called after an update.

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

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

Get an instance of T

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

Return an instance of T

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

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

Get an instance of T

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

Return an instance of T

impl<O: Op + Clone> Factory<Vec<(usize, OpSide), Global>> for FastOpsTemplate<O>

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

Get an instance of T

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

Return an instance of T

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

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

Get an instance of T

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

Return an instance of T

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

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

Get an instance of T

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

Return an instance of T

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

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

Get an instance of T

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

Return an instance of T

impl<O: Op + Clone> Factory<Vec<f64, Global>> for FastOpsTemplate<O>

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

Get an instance of T

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

Return an instance of T

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

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

Get an instance of T

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

Return an instance of T

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

pub 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.

pub 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.

pub 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.

pub 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.

pub 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> IsingManager for FastOpsTemplate<O>

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.

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

Get a ref to a node at position p

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

Get a mutable ref to the node at position p

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

Get the first occupied p if it exists.

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

Get the last occupied p if it exists.

pub 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.

pub 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.

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

Get the previous occupied p compared to node.

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

Get the next occupied p compared to node.

pub 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.

pub 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.

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

Get the nth occupied p.

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

Get the previous p for a given var.

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

Get the next p for a given var.

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

Returns if a given variable is covered by any ops.

pub 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.

pub 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.

pub fn post_loop_update_hook(&mut self)

Called after an update.

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

type Op = O

The op object to manage.

pub fn get_cutoff(&self) -> usize

Get the cutoff for this container.

pub fn set_cutoff(&mut self, cutoff: usize)

Set the cutoff for this container.

pub fn get_n(&self) -> usize

Get the number of non-identity ops.

pub fn get_nvars(&self) -> usize

Get the number of managed variables.

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

Get the pth op, None is identity.

pub fn get_count(&self, bond: usize) -> usize

Gets the count of bonds ops in the graph.

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

Verify the integrity of the OpContainer.

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

pub fn new(nvars: usize) -> Self

Make a new container for nvars.

pub 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> QMCManager for FastOpsTemplate<O>

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

pub 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

pub 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

pub 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.

pub 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.