Struct qoqo::QuantumProgramWrapper

pub struct QuantumProgramWrapper {
    pub internal: QuantumProgram,
}

Represents a quantum program evaluating measurements based on a one or more free float parameters.

The main use of QuantumProgram is to contain a Measurements implementing [crate::measurements::Measure] that measures expectation values or output registers of [crate::Circuit] quantum circuits that contain symbolic parameters. Circuit with symbolic parameters can not be simulated or executed on real hardware. The symbolic parameters need to be replaced with real floating point numbers first. A QuantumProgram contains a list of the free parameters (input_parameter_names) and can automatically replace the parameters with its run methods and return the result.

The QuantumProgram should correspond as closely as possible to a normal mulit-parameter function in classical computing that can be called with a set of parameters and returns a result. It is the intended way to interface between normal program code and roqoqo based quantum programs.

Fields

internal: QuantumProgram

Internal storage of roqoqo::QuantumProgram

Implementations

impl QuantumProgramWrapper

pub fn new(
    measurement: &PyAny,
    input_parameter_names: Vec<String>
) -> PyResult<Self>

Create a QuantumProgram.

Args: measurement: input_parameter_names (Liststr):

Returns: self: The new .

pub fn measurement(&self) -> PyObject

Returns the measurement attribute of the QuantumProgram as Python object.

Returns: PyObject corresponding to the qoqo measurement type of the QuantumProgram, i.e. PauliZProduct, CheatedPauliZProduct, Cheated or ClassicalRegister.

pub fn input_parameter_names(&self) -> Vec<String>

Returns the input_parameter_names attribute of the qoqo QuantumProgram.

Returns: List of input parameter names.

pub fn run(
    &self,
    backend: Py<PyAny>,
    parameters: Option<Vec<f64>>
) -> PyResult<Py<PyAny>>

Runs the QuantumProgram and returns expectation values.

Runs the quantum programm for a given set of parameters passed in the same order as the parameters listed in input_parameter_names and returns expectation values.

Args: backend (Backend): The backend the program is executed on. parameters (Optional[List[float]): List of float parameters of the function call in order of input_parameter_names

pub fn run_registers(
    &self,
    backend: Py<PyAny>,
    parameters: Option<Vec<f64>>
) -> PyResult<Py<PyAny>>

Runs the QuantumProgram and returns the classical registers of the quantum program.

Runs the quantum programm for a given set of parameters passed in the same order as the parameters listed in input_parameter_names and returns the classical register output.
The classical registers usually contain a record of measurement values for the repeated execution of a [crate::Circuit] quantum circuit for real quantum hardware or the readout of the statevector or the density matrix for simulators.

Args: backend (Backend): The backend the program is executed on. parameters (Optional[List[float]): List of float parameters of the function call in order of input_parameter_names

pub fn __copy__(&self) -> QuantumProgramWrapper

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

Returns: QuantumProgram: A deep copy of self.

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

Return a deep copy of the QuantumProgram.

Returns: QuantumProgram: A deep copy of self.

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

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

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

Raises: ValueError: Cannot serialize QuantumProgram to bytes.

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

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

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

Returns: QuantumProgram: The deserialized QuantumProgram.

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

Trait Implementations

impl Clone for QuantumProgramWrapper

fn clone(&self) -> QuantumProgramWrapper

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for QuantumProgramWrapper

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for QuantumProgramWrapper

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl IntoPy<Py<PyAny>> for QuantumProgramWrapper

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

Performs the conversion.

impl PartialEq<QuantumProgramWrapper> for QuantumProgramWrapper

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

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

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

This method tests for !=.

impl PyClass for QuantumProgramWrapper

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.

impl PyClassImpl for QuantumProgramWrapper

const DOC: &'static str = "Represents a quantum program evaluating measurements based on a one or more free float parameters.\n\nThe main use of QuantumProgram is to contain a Measurements implementing [crate::measurements::Measure]\nthat measures expectation values or output registers of [crate::Circuit] quantum circuits that contain\nsymbolic parameters. Circuit with symbolic parameters can not be simulated or executed on real hardware.\nThe symbolic parameters need to be replaced with real floating point numbers first.\nA QuantumProgram contains a list of the free parameters (`input_parameter_names`) and can automatically\nreplace the parameters with its `run` methods and return the result.\n\nThe QuantumProgram should correspond as closely as possible to a normal mulit-parameter function\nin classical computing that can be called with a set of parameters and returns a result.\nIt is the intended way to interface between normal program code and roqoqo based quantum programs.\n\u{0}"

Class doc string

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

type Layout = PyCell<QuantumProgramWrapper>

Layout

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerStub<QuantumProgramWrapper>

This handles following two situations:

fn for_all_items(visitor: &mut dyn FnMut(&PyClassItems))

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyMethods<QuantumProgramWrapper> for PyClassImplCollector<QuantumProgramWrapper>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for QuantumProgramWrapper

type AsRefTarget = PyCell<QuantumProgramWrapper>

Utility type to make Py::as_ref work.

const NAME: &'static str = "QuantumProgram"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::Some("qoqo")

Module name, if any.

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

PyTypeObject instance for this type.

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 Serialize for QuantumProgramWrapper

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for QuantumProgramWrapper