Struct qip::qubit_chainer::SingleRegisterChain

pub struct SingleRegisterChain<'a, B: UnitaryBuilder> { /* fields omitted */ }

Chaining struct for a single Register (which may have multiple indices)

Methods

impl<'a, B: UnitaryBuilder> SingleRegisterChain<'a, B>

pub fn new(builder: &'a mut B, r: Register) -> Self

Make a new SingleRegisterChain. Prefer to use chain.

pub fn release(self) -> Register

Release the contained Register.

pub fn r(self) -> Register

Release the contained Register.

pub fn split(
    self,
    indices: &[u64]
) -> Result<DoubleRegisterChain<'a, B>, CircuitError>

Split the Register, select the given indices and transfer them to a new Register, leave the remaining indices in another Register. This uses the relative indices (0 refers to whatever the first index of the contained Register is).

pub fn split_absolute(
    self,
    selected_indices: &[u64]
) -> Result<DoubleRegisterChain<'a, B>, CircuitError>

Split the Register, select the given indices and transfer them to a new Register, leave the remaining indices in another Register. This uses the absolute indices (0 refers to the 0th absolute index, even if it isn't in the contained Register, throwing an error).

pub fn split_all(self) -> Result<VecRegisterChain<'a, B>, CircuitError>

Split each contained index into its own Register object, returns a chaining struct for the vec of resulting Registers.

pub fn apply_mat(
    self,
    name: &str,
    mat: Vec<Complex<f64>>
) -> Result<Self, CircuitError>

Apply a matrix operation to the contained Register.

pub fn apply_sparse_mat(
    self,
    name: &str,
    mat: Vec<Vec<(u64, Complex<f64>)>>,
    natural_order: bool
) -> Result<Self, CircuitError>

Apply a sparse matrix operation to the contained Register.

pub fn x(self) -> Self

Apply the X operation to the contained Register.

pub fn y(self) -> Self

Apply the Y operation to the contained Register.

pub fn z(self) -> Self

Apply the Z operation to the contained Register.

pub fn hadamard(self) -> Self

Apply a H to the contained Register.

pub fn apply(self, f: impl FnOnce(&mut B, Register) -> Register) -> Self

Map the Register by the given function.

pub fn apply_cut(
    self,
    f: impl FnOnce(&mut B, Register) -> (Register, Register)
) -> DoubleRegisterChain<'a, B>

Map the Register by the given function, resulting in two Registers.

pub fn apply_split(
    self,
    f: impl FnOnce(&mut B, Register) -> Vec<Register>
) -> VecRegisterChain<'a, B>

Map the Register by the given function, resulting in a vec of Registers.

Trait Implementations

impl<'a, B: Debug + UnitaryBuilder> Debug for SingleRegisterChain<'a, B>

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

Formats the value using the given formatter.

impl<'a, B: UnitaryBuilder> Not for SingleRegisterChain<'a, B>

type Output = SingleRegisterChain<'a, B>

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.