Struct qmc::sse::qmc_traits::op_container::BasicOp

pub struct BasicOp<Vars, SubState> where
    Vars: FromIterator<usize> + AsRef<[usize]> + AsMut<[usize]> + Clone + Debug,
    SubState: FromIterator<bool> + AsRef<[bool]> + AsMut<[bool]> + Clone + Debug,  { /* fields omitted */ }

An standard op which covers a number of variables and changes the state from input to output.

Trait Implementations

impl<Vars: Clone, SubState: Clone> Clone for BasicOp<Vars, SubState> where
    Vars: FromIterator<usize> + AsRef<[usize]> + AsMut<[usize]> + Clone + Debug,
    SubState: FromIterator<bool> + AsRef<[bool]> + AsMut<[bool]> + Clone + Debug, 

pub fn clone(&self) -> BasicOp<Vars, SubState>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Vars: Debug, SubState: Debug> Debug for BasicOp<Vars, SubState> where
    Vars: FromIterator<usize> + AsRef<[usize]> + AsMut<[usize]> + Clone + Debug,
    SubState: FromIterator<bool> + AsRef<[bool]> + AsMut<[bool]> + Clone + Debug, 

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

Formats the value using the given formatter.

impl<Vars: Eq, SubState: Eq> Eq for BasicOp<Vars, SubState> where
    Vars: FromIterator<usize> + AsRef<[usize]> + AsMut<[usize]> + Clone + Debug,
    SubState: FromIterator<bool> + AsRef<[bool]> + AsMut<[bool]> + Clone + Debug, 

impl<Vars, SubState> Op for BasicOp<Vars, SubState> where
    Vars: FromIterator<usize> + AsRef<[usize]> + AsMut<[usize]> + Clone + Debug,
    SubState: FromIterator<bool> + AsRef<[bool]> + AsMut<[bool]> + Clone + Debug, 

type Vars = Vars

The list of op variables.

type SubState = SubState

The list of op input and output states.

pub fn diagonal<A, B>(vars: A, bond: usize, state: B, constant: bool) -> Self where
    A: Into<Self::Vars>,
    B: Into<Self::SubState>, 

Make a diagonal op.

pub fn offdiagonal<A, B, C>(
    vars: A,
    bond: usize,
    inputs: B,
    outputs: C,
    constant: bool
) -> Self where
    A: Into<Self::Vars>,
    B: Into<Self::SubState>,
    C: Into<Self::SubState>, 

Make an offdiagonal op.

pub fn is_diagonal(&self) -> bool

Check if the op is diagonal (makes no state changes).

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

Get the relative index of a variable.

pub fn get_vars(&self) -> &[usize]

Get the set of variables used for this op.

pub fn get_bond(&self) -> usize

Get the associated bond number for the op.

pub fn get_inputs(&self) -> &[bool]

Get the input state for the op.

pub fn get_outputs(&self) -> &[bool]

Get the output state for the op.

pub fn clone_and_edit_in_out<F>(&self, f: F) -> Self where
    F: Fn(&mut [bool], &mut [bool]), 

Clone the op and edit inputs and outputs.

pub fn clone_and_edit_in_out_symmetric<F>(&self, f: F) -> Self where
    F: Fn(&mut [bool]), 

Clone the op and edit inputs and outputs. Must edit states symmetrically (diagonal stays diagonal, offdiagonal stays offdiagonal).

pub fn clone_inputs(&self) -> Self::SubState

Get the input state for the op.

pub fn clone_outputs(&self) -> Self::SubState

Get the output state for the op.

pub fn is_constant(&self) -> bool

If the op is always a constant under any bit flip in input or output, then it can be used to mark the edges of clusters.

pub fn edit_in_out<F>(&mut self, f: F) where
    F: Fn(&mut [bool], &mut [bool]), 

Edit inputs and outputs.

pub fn edit_in_out_symmetric<F>(&mut self, f: F) where
    F: Fn(&mut [bool]), 

Edit inputs and outputs. Must edit states symmetrically (diagonal stays diagonal, offdiagonal stays offdiagonal).

pub fn make_vars<V>(vars: V) -> Self::Vars where
    V: IntoIterator<Item = usize>, 

Make vars (this is here mostly due to rust bug 38078)

pub fn make_substate<S>(state: S) -> Self::SubState where
    S: IntoIterator<Item = bool>, 

Make substate (this is here mostly due to rust bug 38078)

impl<Vars: PartialEq, SubState: PartialEq> PartialEq<BasicOp<Vars, SubState>> for BasicOp<Vars, SubState> where
    Vars: FromIterator<usize> + AsRef<[usize]> + AsMut<[usize]> + Clone + Debug,
    SubState: FromIterator<bool> + AsRef<[bool]> + AsMut<[bool]> + Clone + Debug, 

pub fn eq(&self, other: &BasicOp<Vars, SubState>) -> bool

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

pub fn ne(&self, other: &BasicOp<Vars, SubState>) -> bool

This method tests for !=.

impl<Vars, SubState> StructuralEq for BasicOp<Vars, SubState> where
    Vars: FromIterator<usize> + AsRef<[usize]> + AsMut<[usize]> + Clone + Debug,
    SubState: FromIterator<bool> + AsRef<[bool]> + AsMut<[bool]> + Clone + Debug, 

impl<Vars, SubState> StructuralPartialEq for BasicOp<Vars, SubState> where
    Vars: FromIterator<usize> + AsRef<[usize]> + AsMut<[usize]> + Clone + Debug,
    SubState: FromIterator<bool> + AsRef<[bool]> + AsMut<[bool]> + Clone + Debug,