Enum ResultData

pub enum ResultData {
    Qvm(QvmResultData),
    Qpu(QpuResultData),
}

Represents the two possible types of data returned from either the QVM or a real QPU. Each variant contains the original data returned from its respective executor.

Usage

Your usage of ResultData will depend on the types of programs you are running and where. The to_register_map() method will attempt to build a RegisterMap out of the data, where each register name is mapped to a 2-dimensional rectangular RegisterMatrix where each row represents the final values in each register index for a particular shot. This is often the desired form of the data and it is probably what you want. This transformation isn’t always possible, in which case to_register_map() will return an error.

To understand why this transformation can fail, we need to understand a bit about how readout data is returned from the QVM and from a real QPU:

The QVM treats each DECLARE statement as initialzing some amount of memory. This memory works as one might expect it to. It is zero-initialized on each shot, and subsequent writes to the same region overwrite the previous value. The QVM returns memory at the end of every shot. This means we get the last value in every memory reference for each shot, which is exactly the representation we want for a RegisterMatrix. For this reason, to_register_map() should always succeed for ResultData::Qvm.

The QPU on the other hand doesn’t use the same memory model as the QVM. Each memory reference (ie. “ro[0]”) is more like a stream than a value in memory. Every MEASURE to a memory reference emits a new value to said stream. This means that the number of values per memory reference can vary per shot. For this reason, it’s not always clear what the final value in each shot was for a particular reference. When this is the case, to_register_map() will return an error as it’s impossible to build a correct RegisterMatrix from the data without knowing the intent of the program that was run. Instead, it’s recommended to build the RegisterMatrix you need from the inner QpuResultData data using the knowledge of your program to choose the correct readout values for each shot.

Variants

Qvm(QvmResultData)

Data returned from the QVM, stored as QvmResultData

Qpu(QpuResultData)

Readout data returned from the QPU, stored as QpuResultData

Implementations

impl ResultData

pub fn as_qvm_mut(&mut self) -> Option<&mut QvmResultData>

Optionally returns mutable references to the inner fields if this is a ResultData::Qvm, otherwise None

pub fn as_qvm(&self) -> Option<&QvmResultData>

Optionally returns references to the inner fields if this is a ResultData::Qvm, otherwise None

pub fn into_qvm(self) -> Result<QvmResultData, Self>

Returns the inner fields if this is a ResultData::Qvm, otherwise returns back the enum in the Err case of the result

pub fn as_qpu_mut(&mut self) -> Option<&mut QpuResultData>

Optionally returns mutable references to the inner fields if this is a ResultData::Qpu, otherwise None

pub fn as_qpu(&self) -> Option<&QpuResultData>

Optionally returns references to the inner fields if this is a ResultData::Qpu, otherwise None

pub fn into_qpu(self) -> Result<QpuResultData, Self>

Returns the inner fields if this is a ResultData::Qpu, otherwise returns back the enum in the Err case of the result

impl ResultData

pub fn to_register_map( &self, ) -> Result<RegisterMap, RegisterMatrixConversionError>

Convert ResultData from its inner representation as QvmResultData or QpuResultData into a RegisterMap. The RegisterMatrix for each register will be constructed such that each row contains all the final values in the register for a single shot.

Errors

Returns a RegisterMatrixConversionError if the inner execution data for any of the registers would result in a jagged matrix. QpuResultData data is captured per measure, meaning a value is returned for every measure to a memory reference, not just once per shot. This is often the case in programs that use mid-circuit measurement or dynamic control flow, where measurements to the same memory reference might occur multiple times in a shot, or be skipped conditionally. In these cases, building a rectangular RegisterMatrix would necessitate making assumptions about the data that could skew the data in undesirable ways. Instead, it’s recommended to manually build a matrix from QpuResultData that accurately selects the last value per-shot based on the program that was run.

Trait Implementations

impl Clone for ResultData

fn clone(&self) -> ResultData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ResultData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResultData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ResultData

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for ResultData

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 ResultData