Struct ErrorPatternReader 

pub struct ErrorPatternReader {
    pub vertices: Vec<CodeVertex>,
    pub edges: Vec<CodeEdge>,
    pub syndrome_patterns: Vec<SyndromePattern>,
    pub defect_index: usize,
    pub cyclic_syndrome: bool,
}

read from file, including the error patterns; the point is to avoid bad cache performance, because generating random error requires iterating over a large memory space, invalidating all cache. also, this can reduce the time of decoding by prepare the data before hand and could be shared between different partition configurations

Fields

vertices: Vec<CodeVertex>

vertices in the code

edges: Vec<CodeEdge>

nearest-neighbor edges in the decoding graph

syndrome_patterns: Vec<SyndromePattern>

pre-generated syndrome patterns

defect_index: usize

cursor of current errors

cyclic_syndrome: bool

Implementations

impl ErrorPatternReader

pub fn py_new(filename: String, cyclic_syndrome: bool) -> Self

impl ErrorPatternReader

pub fn new(config: Value) -> Self

Trait Implementations

impl Clone for ErrorPatternReader

fn clone(&self) -> ErrorPatternReader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorPatternReader

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

Formats the value using the given formatter.

impl ExampleCode for ErrorPatternReader

fn vertices_edges(&mut self) -> (&mut Vec<CodeVertex>, &mut Vec<CodeEdge>)

get mutable references to vertices and edges

fn immutable_vertices_edges(&self) -> (&Vec<CodeVertex>, &Vec<CodeEdge>)

fn generate_random_errors(&mut self, _seed: u64) -> SyndromePattern

generate random errors based on the edge probabilities and a seed for pseudo number generator

fn vertex_num(&self) -> VertexNum

get the number of vertices

fn compute_weights(&mut self, max_half_weight: Weight)

generic method that automatically computes integer weights from probabilities, scales such that the maximum integer weight is 10000 and the minimum is 1

fn sanity_check(&self) -> Result<(), String>

sanity check to avoid duplicate edges that are hard to debug

fn set_probability(&mut self, p: f64)

set probability of all edges; user can set individual probabilities

fn set_erasure_probability(&mut self, pe: f64)

set erasure probability of all edges; user can set individual probabilities

fn fill_vertices(&mut self, vertex_num: VertexNum)

automatically create vertices given edges

fn get_positions(&self) -> Vec<VisualizePosition>

gather all positions of vertices

fn get_initializer(&self) -> SolverInitializer

generate standard interface to instantiate Fusion blossom solver

fn set_defect_vertices(&mut self, defect_vertices: &[VertexIndex])

set defect vertices (non-trivial measurement result in case of single round of measurement, or different result from the previous round in case of multiple rounds of measurement)

fn set_erasures(&mut self, erasures: &[EdgeIndex])

set erasure edges

fn set_syndrome(&mut self, syndrome_pattern: &SyndromePattern)

set syndrome

fn get_defect_vertices(&self) -> Vec<VertexIndex>

get current defect vertices

fn get_erasures(&self) -> Vec<EdgeIndex>

get current erasure edges

fn get_syndrome(&self) -> SyndromePattern

get current syndrome

fn generate_errors(&mut self, edge_indices: &[EdgeIndex]) -> SyndromePattern

fn clear_errors(&mut self)

fn is_virtual(&self, vertex_idx: usize) -> bool

fn is_defect(&self, vertex_idx: usize) -> bool

fn reorder_vertices(&mut self, sequential_vertices: &[VertexIndex])

reorder the vertices such that new vertices (the indices of the old order) is sequential