qudit-circuit 0.3.2

Accelerated and Extensible Quantum Library
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
76
77
78
79
80
81
82
83
84

use super::InstructionId;
use crate::circuit::PyQuditCircuit;
use crate::cycle::{CycleId, CycleIndex};
use crate::wire::WireList;
use pyo3::exceptions::PyRuntimeError;
use pyo3::prelude::*;
use pyo3_stub_gen::derive::*;

#[gen_stub_pyclass]
#[pyclass(name = "InstructionReference", module = "openqudit.circuit")]
pub struct PyInstructionReference {
    inst_id: InstructionId,
    circuit_ref: Py<PyQuditCircuit>,
}

impl PyInstructionReference {
    pub fn new(inst_id: InstructionId, circuit_ref: Py<PyQuditCircuit>) -> Self {
        Self {
            inst_id,
            circuit_ref,
        }
    }
}

#[gen_stub_pymethods]
#[pymethods]
impl PyInstructionReference {
    fn name<'py>(&self, py: Python<'py>) -> PyResult<String> {
        let circuit = &self.circuit_ref.bind(py).borrow().circuit;
        match circuit.get(self.inst_id) {
            Some(inst) => Ok(circuit
                .operations()
                .name(inst.op_code())
                .replace("_subbed", "")),
            None => Err(PyRuntimeError::new_err("Invalid instruction reference.")),
        }
    }

    fn wires<'py>(&self, py: Python<'py>) -> PyResult<WireList> {
        let circuit = &self.circuit_ref.bind(py).borrow().circuit;
        match circuit.get(self.inst_id) {
            Some(inst) => Ok(inst.wires()),
            None => Err(PyRuntimeError::new_err("Invalid instruction reference.")),
        }
    }

    fn params<'py>(&self, py: Python<'py>) -> PyResult<Vec<crate::param::Parameter>> {
        let circuit = &self.circuit_ref.bind(py).borrow().circuit;
        let params = circuit.params();
        match circuit.get(self.inst_id) {
            Some(inst) => {
                let param_indices = params.convert_ids_to_indices(inst.params());
                Ok(param_indices.iter().map(|i| params[i].clone()).collect())
            }
            None => Err(PyRuntimeError::new_err("Invalid Instruction reference.")),
        }
    }

    fn cycle_id(&self) -> CycleId {
        self.inst_id.cycle()
    }

    fn cycle_index<'py>(&self, py: Python<'py>) -> PyResult<CycleIndex> {
        let circuit = &self.circuit_ref.bind(py).borrow().circuit;
        match circuit.cycle_id_to_index(self.inst_id.cycle()) {
            Some(cycle_index) => Ok(cycle_index),
            None => Err(PyRuntimeError::new_err("Invalid instruction reference.")),
        }
    }

    fn num_qudits<'py>(&self, py: Python<'py>) -> PyResult<usize> {
        self.wires(py).map(|w| w.get_num_qudits())
    }

    fn num_dits<'py>(&self, py: Python<'py>) -> PyResult<usize> {
        self.wires(py).map(|w| w.get_num_dits())
    }
}

fn register(parent_module: &Bound<'_, PyModule>) -> PyResult<()> {
    parent_module.add_class::<PyInstructionReference>()?;
    Ok(())
}
inventory::submit!(crate::python::PyCircuitRegistrar { func: register });