Struct OpenQASMProgram

pub struct OpenQASMProgram {
    pub gates: HashMap<String, Gate>,
    pub qregs: HashMap<String, usize>,
    pub cregs: HashMap<String, usize>,
    pub operations: Vec<(Option<Condition>, Operation)>,
}

The type returned after performing semantic analysis on an AST.

It contains the quantum and classical registers and the gates defined in the program. I also contains a list of the Operations to perform in order. The Operations are optionally paired with a Condition for running. the operation.

Fields

gates: HashMap<String, Gate>

The custom gates defined in the openqasm program. Maps the gate names to Gates

qregs: HashMap<String, usize>

The quantum registers defined in the openqasm program. Maps the register names to the size of the register.

cregs: HashMap<String, usize>

The classical registers defined in the openqasm program. Maps the register names to the size of the register.

operations: Vec<(Option<Condition>, Operation)>

The Operations to execute when running the openqasm program. The operations are optionally paired with a Condition which controls whether to run the operation or not.

Implementations

impl OpenQASMProgram

pub fn from_ast(ast_node: &MainProgram) -> Result<Self, SemanticError>

The main function for running semantic analysis on an AST.

impl OpenQASMProgram

pub fn get_basic_operations(&self) -> Vec<(Option<Condition>, BasicOp)>

Retrieves a list of BasicOps from an OpenQASMProgram so that the operations can be for example perfomed by a simulator.

Each BasicOp can optionally be paired with a Condition, if the operation was applied in an ‘if’ statement.

Examples found in repository

examples/example.rs (line 62)

fn main() {
    let example_dir = Path::new(file!()).parent().unwrap();
    let qasm_path = example_dir.join(Path::new("example.qasm"));
    println!("{:?}", qasm_path);
    let program = parse_openqasm(&qasm_path).unwrap();

    println!("Quantum registers:");
    for (name, reg_size) in program.qregs.iter() {
        println!("    {}[{}]", name, reg_size);
    }

    println!("Classical registers:");
    for (name, reg_size) in program.cregs.iter() {
        println!("    {}[{}]", name, reg_size);
    }

    println!("Gates:");
    for (name, gate) in program.gates.iter() {
        println!(
            "    {} | parameters: {}, arguments: {}",
            name, gate.num_arguments, gate.num_targets
        );

        for op in gate.operations.iter() {
            let gate_name = match op {
                GateOperation::U(_, _, _, _) => "U".to_string(),
                GateOperation::CX(_, _) => "CX".to_string(),
                GateOperation::Custom(gate_name, _, _) => gate_name.clone(),
            };
            println!("        {}", gate_name);
        }
    }

    println!("Operations:");
    for (cond, operation) in program.operations.iter() {
        print!("    ");

        if let Some(cond) = cond {
            print!("if({} == {}) ", cond.0, cond.1);
        }

        match operation {
            Operation::U(p1, p2, p3, qbit) => {
                println!("U({},{},{}) {}[{}]", p1, p2, p3, qbit.0, qbit.1)
            }
            Operation::CX(q1, q2) => println!("CX {}[{}], {}[{}]", q1.0, q1.1, q2.0, q2.1),
            Operation::Custom(name, ps, qs) => println!("{}({:?}) {:?}", name, ps, qs),
            Operation::Measure(q, c) => println!("measure {}[{}] -> {}[{}]", q.0, q.1, c.0, c.1),
            Operation::ResetQ(q) => println!("reset {}[{}]", q.0, q.1),
            Operation::ResetC(c) => println!("reset {}[{}]", c.0, c.1),
        }
    }
    println!("Basic operations:");
    for (cond, operation) in program.get_basic_operations().iter() {
        print!("    ");

        if let Some(cond) = cond {
            print!("if({} == {}) ", cond.0, cond.1);
        }

        match operation {
            BasicOp::U(p1, p2, p3, qbit) => {
                println!("U({},{},{}) {}[{}]", p1, p2, p3, qbit.0, qbit.1)
            }
            BasicOp::CX(q1, q2) => println!("CX {}[{}], {}[{}]", q1.0, q1.1, q2.0, q2.1),
            BasicOp::Measure(q, c) => println!("measure {}[{}] -> {}[{}]", q.0, q.1, c.0, c.1),
            BasicOp::ResetQ(q) => println!("reset {}[{}]", q.0, q.1),
            BasicOp::ResetC(c) => println!("reset {}[{}]", c.0, c.1),
        }
    }

}