faultscope-core 0.2.12

Python-independent circuit, DEM, sampling, and decoder primitives for FaultScope
Documentation
use crate::{NpError, NpResult};

pub(super) fn flat_range(index: usize, words: usize) -> std::ops::Range<usize> {
    let start = index * words;
    start..start + words
}

pub(super) fn xor_word_slices(target: &mut [u64], source: &[u64]) {
    for (left, right) in target.iter_mut().zip(source) {
        *left ^= *right;
    }
}

pub(super) fn xor_within_flat_frame(frame: &mut [u64], target: usize, source: usize, words: usize) {
    let source = frame[flat_range(source, words)].to_vec();
    xor_word_slices(&mut frame[flat_range(target, words)], &source);
}

pub(super) fn xor_between_flat_frames(
    source: &[u64],
    target: &mut [u64],
    source_idx: usize,
    target_idx: usize,
    words: usize,
) {
    xor_word_slices(
        &mut target[flat_range(target_idx, words)],
        &source[flat_range(source_idx, words)],
    );
}

pub(super) fn swap_flat_rows(frame: &mut [u64], left: usize, right: usize, words: usize) {
    for word_index in 0..words {
        frame.swap(left * words + word_index, right * words + word_index);
    }
}

pub(super) fn swap_flat_rows_between_frames(
    left: &mut [u64],
    right: &mut [u64],
    index: usize,
    words: usize,
) {
    for word_index in 0..words {
        std::mem::swap(
            &mut left[index * words + word_index],
            &mut right[index * words + word_index],
        );
    }
}

pub(super) fn zero_flat_row(frame: &mut [u64], index: usize, words: usize) {
    frame[flat_range(index, words)].fill(0);
}

pub(super) fn xor_flat_frame_measurement_flip_into(
    out: &mut [u64],
    x_frame: &[u64],
    z_frame: &[u64],
    qubits: &[usize],
    pauli: &str,
    words: usize,
) -> NpResult<()> {
    if qubits.len() != pauli.len() {
        return Err(NpError::new("qubits and pauli must have the same length"));
    }
    for (qubit, local) in qubits.iter().zip(pauli.as_bytes()) {
        match *local {
            b'I' => {}
            b'X' => xor_word_slices(out, &z_frame[flat_range(*qubit, words)]),
            b'Z' => xor_word_slices(out, &x_frame[flat_range(*qubit, words)]),
            b'Y' => {
                xor_word_slices(out, &x_frame[flat_range(*qubit, words)]);
                xor_word_slices(out, &z_frame[flat_range(*qubit, words)]);
            }
            _ => {
                return Err(NpError::new(format!(
                    "unsupported Pauli {:?}",
                    *local as char
                )));
            }
        }
    }
    Ok(())
}

pub(super) fn set_flat_event_bit(frame: &mut [u64], row: usize, words: usize, event_index: usize) {
    let word_index = event_index / 64;
    if word_index >= words {
        return;
    }
    let bit_index = event_index % 64;
    let offset = row * words + word_index;
    if let Some(word) = frame.get_mut(offset) {
        *word |= 1u64 << bit_index;
    }
}

pub(super) fn set_event_bit_in_words(words: &mut [u64], event_index: usize) {
    let word_index = event_index / 64;
    let bit_index = event_index % 64;
    if let Some(word) = words.get_mut(word_index) {
        *word |= 1u64 << bit_index;
    }
}