Struct Qasm3Builder 

pub struct Qasm3Builder {
    pub circuit: Qasm3Circuit,
    pub num_qubits: usize,
    pub num_bits: usize,
}

Builder for QASM 3.0 circuits

Fields

circuit: Qasm3Circuit

The circuit being built

num_qubits: usize

Number of qubits in the circuit

num_bits: usize

Number of classical bits in the circuit

Implementations

impl Qasm3Builder

pub fn new(num_qubits: usize) -> Self

Create a new builder with specified number of qubits

pub fn with_bits(self, num_bits: usize) -> Self

Set number of classical bits

pub fn gate(&mut self, name: &str, qubits: &[usize]) -> DeviceResult<&mut Self>

Add a gate operation

pub fn gate_with_params( &mut self, name: &str, params: &[f64], qubits: &[usize], ) -> DeviceResult<&mut Self>

Add a gate with parameters

pub fn ctrl_gate( &mut self, name: &str, control: usize, target: usize, params: &[f64], ) -> DeviceResult<&mut Self>

Add a controlled gate

pub fn inv_gate( &mut self, name: &str, qubits: &[usize], ) -> DeviceResult<&mut Self>

Add an inverse gate

pub fn measure(&mut self, qubit: usize, bit: usize) -> DeviceResult<&mut Self>

Add measurement

pub fn measure_all(&mut self) -> DeviceResult<&mut Self>

Measure all qubits

pub fn reset(&mut self, qubit: usize) -> DeviceResult<&mut Self>

Add reset operation

pub fn barrier(&mut self, qubits: &[usize]) -> DeviceResult<&mut Self>

Add barrier

pub fn if_statement<F>( &mut self, condition: &str, then_block: F, ) -> DeviceResult<&mut Self>

where F: FnOnce(&mut Qasm3Builder) -> DeviceResult<()>,

Add if statement (dynamic circuit)

pub fn if_else_statement<F, G>( &mut self, condition: &str, then_block: F, else_block: G, ) -> DeviceResult<&mut Self>

where F: FnOnce(&mut Qasm3Builder) -> DeviceResult<()>, G: FnOnce(&mut Qasm3Builder) -> DeviceResult<()>,

Add if-else statement (dynamic circuit)

pub fn while_loop<F>( &mut self, condition: &str, body: F, ) -> DeviceResult<&mut Self>

where F: FnOnce(&mut Qasm3Builder) -> DeviceResult<()>,

Add while loop

pub fn for_loop<F>( &mut self, var_name: &str, range: &str, body: F, ) -> DeviceResult<&mut Self>

where F: FnOnce(&mut Qasm3Builder) -> DeviceResult<()>,

Add for loop

pub fn switch_statement<F>( &mut self, expression: &str, case_builder: F, ) -> DeviceResult<&mut Self>

where F: FnOnce(&mut SwitchBuilder) -> DeviceResult<()>,

Add switch statement (QASM 3.0 dynamic circuit feature)

Arguments

• expression - The expression to switch on (e.g., “c”)
• case_builder - A closure that builds the switch cases

Example

builder.switch_statement("c", |sw| {
    sw.case(&[0], |b| b.gate("x", &[0]))?;
    sw.case(&[1], |b| b.gate("y", &[0]))?;
    sw.default(|b| b.gate("z", &[0]))?;
    Ok(())
})?;

pub fn assign(&mut self, target: &str, value: &str) -> &mut Self

Add classical assignment

Arguments

• target - Target variable (e.g., "c[0]")
• value - Value expression (e.g., "c[0] + 1", "c[0] & c[1]")

pub fn comment(&mut self, text: &str) -> &mut Self

Add comment

pub fn build(self) -> DeviceResult<Qasm3Circuit>

Build the QASM 3.0 circuit