Struct qoqo::CircuitWrapper

pub struct CircuitWrapper {
    pub internal: Circuit,
}

Circuit of Operations.

A quantum program is represented as a linear sequence of Operations.

Fields

internal: Circuit

Internal storage of roqoqo::Circuit

Implementations

impl CircuitWrapper

pub fn from_pyany(input: Py<PyAny>) -> PyResult<Circuit>

Extracts a Circuit from a CircuitWrapper python object.

When working with qoqo and other rust based python packages compiled separately a downcast will not detect that two CircuitWrapper objects are compatible. Provides a custom function to convert qoqo Circuits between different Python packages.

Arguments:

input - The Python object that should be casted to a roqoqo::Circuit

impl CircuitWrapper

pub fn new() -> Self

Create an empty quantum Circuit.

Returns: self: The new, empty Circuit.

pub fn substitute_parameters( &self, substitution_parameters: HashMap<&str, f64> ) -> PyResult<Self>

Substitute the symbolic parameters in a clone of the Circuit according to the substitution_parameters input.

Args: substitution_parameters (dict[str, float]): The dictionary containing the substitutions to use in the Circuit.

Returns: self: The Circuit with the parameters substituted.

Raises: RuntimeError: The parameter substitution failed.

pub fn remap_qubits(&self, mapping: HashMap<usize, usize>) -> PyResult<Self>

Remap qubits in operations in clone of Circuit.

Args: mapping (dict[int, int]): The dictionary containing the {qubit: qubit} mapping to use in the Circuit.

Returns: self: The Circuit with the qubits remapped.

Raises: RuntimeError: The qubit remapping failed.

pub fn overrotate(&self) -> PyResult<Self>

Return clone of the circuit with all overrotation Pragmas applied.

Returns: Circuit: Circuit with the overrotation applied

Raises: RuntimeError: Error applying PragmaOverrotation in circuit. Example:

circuit = Circuit() circuit += PragmaOverrotation(“RotateY”, [1,], 20.0, 30.0) circuit += RotateX(0, 0.0) circuit += RotateY(0, 1.0) circuit += RotateY(1, 2.0) circuit += RotateY(1, 3.0) circuit_overrotated = circuit.overrotate() print(circuit) print(circuit_overrotated)

pub fn count_occurences(&self, operations: Vec<&str>) -> usize

Count the number of occurences of a set of operation tags in the circuit.

Args: operations (liststr): List of operation tags that should be counted.

Returns: int: The number of occurences of these operation tags.

pub fn get_operation_types(&self) -> HashSet<&str>

Return a list of the hqslang names of all operations occuring in the circuit.

Returns: setstr: The operation types in the Circuit.

pub fn __copy__(&self) -> CircuitWrapper

Return a copy of the Circuit (copy here produces a deepcopy).

Returns: Circuit: A deep copy of self.

pub fn __deepcopy__(&self, _memodict: Py<PyAny>) -> CircuitWrapper

Return a deep copy of the Circuit.

Returns: Circuit: A deep copy of self.

pub fn to_bincode(&self) -> PyResult<Py<PyByteArray>>

Return the bincode representation of the Circuit using the bincode crate.

Returns: ByteArray: The serialized Circuit (in bincode form).

Raises: ValueError: Cannot serialize Circuit to bytes.

pub fn from_bincode(input: &PyAny) -> PyResult<Self>

Convert the bincode representation of the Circuit to a Circuit using the bincode crate.

Args: input (ByteArray): The serialized Circuit (in bincode form).

Returns: Circuit: The deserialized Circuit.

Raises: TypeError: Input cannot be converted to byte array. ValueError: Input cannot be deserialized to Circuit.

pub fn from_json(json_string: &str) -> PyResult<Self>

Convert the json representation of a Circuit to a Circuit.

Args: input (str): The serialized Circuit in json form.

Returns: Circuit: The deserialized Circuit.

Raises: ValueError: Input cannot be deserialized to Circuit.

pub fn get(&self, index: usize) -> PyResult<PyObject>

Return a copy of the Operation at a certain index of the Circuit.

Args: index (int): The index of the Operation to get in the Circuit.

Returns: Operation: The operation at the given index (if it exists).

Raises: IndexError: Index out of range.

pub fn get_slice( &self, start: Option<usize>, stop: Option<usize> ) -> PyResult<CircuitWrapper>

Return the copy of a slice of the Circuit.

Args: start (Optional[int]): The starting index of the slice (inclusive). stop (Optional[int]): The stopping index of the slice (exclusive).

Returns: Circuit: The slice of the operations in the Circuit with the specified indices.

Raises: IndexError: Stop index smaller than start index. IndexError: Stop index out of range. IndexError: Start index out of range.

pub fn definitions(&self) -> PyResult<Vec<PyObject>>

Return a list of definitions in the Circuit.

Definitions need to be unique.

Returns: list[Operation]: A vector of the definitions in the Circuit.

pub fn operations(&self) -> PyResult<Vec<PyObject>>

Return a list of all operations in the Circuit.

Returns: list[Operation]: A vector of the operations in the Circuit.

pub fn filter_by_tag(&self, tag: &str) -> PyResult<Vec<PyObject>>

Return a list of operations with given tag.

Args: tag (str): tag by which to filter operations.

Returns: list[Operation]: A vector of the operations with the specified tag in the Circuit.

pub fn add(&mut self, op: &PyAny) -> PyResult<()>

Add an Operation to Circuit.

Args: op (Operation): The Operation to add to the Circuit.

Trait Implementations

impl Clone for CircuitWrapper

fn clone(&self) -> CircuitWrapper

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CircuitWrapper

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CircuitWrapper

fn default() -> Self

Returns the “default value” for a type.

impl IntoPy<Py<PyAny>> for CircuitWrapper

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl PartialEq for CircuitWrapper

fn eq(&self, other: &CircuitWrapper) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PyClass for CircuitWrapper

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for CircuitWrapper

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<CircuitWrapper>

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForCircuitWrapper

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature<CircuitWrapper> for PyClassImplCollector<CircuitWrapper>

fn new_text_signature(self) -> Option<&'static str>

impl PyClass__add__SlotFragment<CircuitWrapper> for PyClassImplCollector<CircuitWrapper>

unsafe fn __add__( self, py: Python<'_>, _raw_slf: *mut PyObject, arg0: *mut PyObject ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__setitem__SlotFragment<CircuitWrapper> for PyClassImplCollector<CircuitWrapper>

unsafe fn __setitem__( self, py: Python<'_>, _raw_slf: *mut PyObject, arg0: *mut PyObject, arg1: NonNull<PyObject> ) -> PyResult<()>

Safety: _slf and _attr must be valid non-null Python objects

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a CircuitWrapper

type Holder = Option<PyRef<'py, CircuitWrapper>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut CircuitWrapper

type Holder = Option<PyRefMut<'py, CircuitWrapper>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl PyTypeInfo for CircuitWrapper

type AsRefTarget = PyCell<CircuitWrapper>

Utility type to make Py::as_ref work.

const NAME: &'static str = "Circuit"

Class name.

const MODULE: Option<&'static str> = _

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> &PyType

Returns the safe abstraction over the type object.

fn is_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.

impl StructuralPartialEq for CircuitWrapper