qecp 0.2.7

Quantum Error Correction Playground for Surface Code Research
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

#![allow(non_snake_case)]

use super::blossom_v;
#[cfg(feature = "python_binding")]
use super::pyo3::prelude::*;
#[cfg(feature = "python_binding")]
use super::pyo3::types::IntoPyDict;
use crate::cli::*;

impl TestCommands {
    pub fn run(self) {
        match self {
            Self::DebugTests => debug_tests(),
            Self::ArchivedDebugTests => archived_debug_tests(),
            Self::All => {
                // remember to add new test functions here
                debug_tests();
                archived_debug_tests();
            }
        }
    }
}

fn archived_debug_tests() {
    cfg_if::cfg_if! {
        if #[cfg(feature="python_binding")] {
            // call python networkx.algorithms.matching.max_weight_matching
            Python::with_gil(|py| {
                (|py: Python| -> PyResult<()> {
                    let networkx = py.import("networkx")?;
                    let G = networkx.call_method0("Graph")?;
                    let weighted_edges = vec![
                        (0, 1, -3.),
                        (1, 2, -2.),
                        (2, 0, -3.),
                        (0, 3, -1.),
                        (1, 4, -2.),
                        (2, 5, -1.),
                        (3, 4, 0.),
                        (3, 5, 0.),
                        (4, 5, 0.),
                    ].to_object(py);
                    G.call_method1("add_weighted_edges_from", (weighted_edges,))?;
                    let max_weight_matching = networkx.getattr("algorithms")?.getattr("matching")?.getattr("max_weight_matching")?;
                    let dict = vec![("maxcardinality", true)].into_py_dict(py);
                    let matched: std::collections::HashSet<(usize, usize)> = max_weight_matching.call((G,), Some(dict))?.extract()?;
                    println!("{:?}", matched);
                    Ok(())
                })(py).map_err(|e| {
                    e.print_and_set_sys_last_vars(py);
                })
            }).expect("python run failed");
        } else {
            println!("[error] compiling feature `python_binding` not enabled")
        }
    }
    {
        // call blossom V matching
        let weighted_edges = vec![
            (0, 1, -3.),
            (1, 2, -2.),
            (2, 0, -3.),
            (0, 3, -1.),
            (1, 4, -2.),
            (2, 5, -1.),
            (3, 4, 0.),
            (3, 5, 0.),
            (4, 5, 0.),
        ];
        let matched = blossom_v::maximum_weight_perfect_matching_compatible(6, weighted_edges);
        println!("{:?}", matched);
    }
}

fn debug_tests() {}