Trait ChainableState 

pub trait ChainableState {
    // Required methods
    fn h(self, index: usize) -> Result<State, Error>;
    fn h_multi(self, qubits: &[usize]) -> Result<State, Error>;
    fn ch_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
    ) -> Result<State, Error>;
    fn x(self, index: usize) -> Result<State, Error>;
    fn x_multi(self, qubits: &[usize]) -> Result<State, Error>;
    fn cx_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
    ) -> Result<State, Error>;
    fn y(self, index: usize) -> Result<State, Error>;
    fn y_multi(self, qubits: &[usize]) -> Result<State, Error>;
    fn cy_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
    ) -> Result<State, Error>;
    fn z(self, index: usize) -> Result<State, Error>;
    fn z_multi(self, qubits: &[usize]) -> Result<State, Error>;
    fn cz_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
    ) -> Result<State, Error>;
    fn i(self, qubit: usize) -> Result<State, Error>;
    fn i_multi(self, qubits: &[usize]) -> Result<State, Error>;
    fn ci_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
    ) -> Result<State, Error>;
    fn s(self, index: usize) -> Result<State, Error>;
    fn s_multi(self, qubits: &[usize]) -> Result<State, Error>;
    fn cs_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
    ) -> Result<State, Error>;
    fn t(self, index: usize) -> Result<State, Error>;
    fn t_multi(self, qubits: &[usize]) -> Result<State, Error>;
    fn ct_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
    ) -> Result<State, Error>;
    fn s_dag(self, index: usize) -> Result<State, Error>;
    fn s_dag_multi(self, qubits: &[usize]) -> Result<State, Error>;
    fn cs_dag_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
    ) -> Result<State, Error>;
    fn t_dag(self, index: usize) -> Result<State, Error>;
    fn t_dag_multi(self, qubits: &[usize]) -> Result<State, Error>;
    fn ct_dag_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
    ) -> Result<State, Error>;
    fn p(self, index: usize, angle: f64) -> Result<State, Error>;
    fn p_multi(self, qubits: &[usize], angle: f64) -> Result<State, Error>;
    fn cp_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
        angle: f64,
    ) -> Result<State, Error>;
    fn rx(self, index: usize, angle: f64) -> Result<State, Error>;
    fn rx_multi(self, qubits: &[usize], angle: f64) -> Result<State, Error>;
    fn crx_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
        angle: f64,
    ) -> Result<State, Error>;
    fn ry(self, index: usize, angle: f64) -> Result<State, Error>;
    fn ry_multi(self, qubits: &[usize], angle: f64) -> Result<State, Error>;
    fn cry_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
        angle: f64,
    ) -> Result<State, Error>;
    fn rz(self, index: usize, angle: f64) -> Result<State, Error>;
    fn rz_multi(self, qubits: &[usize], angle: f64) -> Result<State, Error>;
    fn crz_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
        angle: f64,
    ) -> Result<State, Error>;
    fn unitary(
        self,
        index: usize,
        unitary: [[Complex<f64>; 2]; 2],
    ) -> Result<State, Error>;
    fn unitary_multi(
        self,
        qubits: &[usize],
        unitary: [[Complex<f64>; 2]; 2],
    ) -> Result<State, Error>;
    fn cunitary_multi(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
        unitary: [[Complex<f64>; 2]; 2],
    ) -> Result<State, Error>;
    fn ry_phase(
        self,
        index: usize,
        angle: f64,
        phase: f64,
    ) -> Result<State, Error>;
    fn ry_phase_multi(
        self,
        qubits: &[usize],
        angle: f64,
        phase: f64,
    ) -> Result<State, Error>;
    fn cry_phase_gates(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
        angle: f64,
        phase: f64,
    ) -> Result<State, Error>;
    fn ry_phase_dag(
        self,
        index: usize,
        angle: f64,
        phase: f64,
    ) -> Result<State, Error>;
    fn ry_phase_dag_multi(
        self,
        qubits: &[usize],
        angle: f64,
        phase: f64,
    ) -> Result<State, Error>;
    fn cry_phase_dag_gates(
        self,
        target_qubits: &[usize],
        control_qubits: &[usize],
        angle: f64,
        phase: f64,
    ) -> Result<State, Error>;
    fn cnot(self, control: usize, target: usize) -> Result<State, Error>;
    fn swap(self, qubit1: usize, qubit2: usize) -> Result<State, Error>;
    fn cswap(
        self,
        target1: usize,
        target2: usize,
        controls: &[usize],
    ) -> Result<State, Error>;
    fn toffoli(
        self,
        control1: usize,
        control2: usize,
        target: usize,
    ) -> Result<State, Error>;
    fn matchgate(
        self,
        target: usize,
        theta: f64,
        phi1: f64,
        phi2: f64,
    ) -> Result<State, Error>;
    fn cmatchgate(
        self,
        target: usize,
        theta: f64,
        phi1: f64,
        phi2: f64,
        controls: &[usize],
    ) -> Result<State, Error>;
    fn operate(
        self,
        unitary: impl Operator,
        target_qubits: &[usize],
        control_qubits: &[usize],
    ) -> Result<State, Error>;
    fn measure(
        self,
        basis: MeasurementBasis,
        measured_qubits: &[usize],
    ) -> Result<MeasurementResult, Error>;
    fn measure_n(
        self,
        basis: MeasurementBasis,
        measured_qubits: &[usize],
        n: usize,
    ) -> Result<Vec<MeasurementResult>, Error>;
}

A trait to enable chainable operations on Result<State, Error>

Required Methods

fn h(self, index: usize) -> Result<State, Error>

Applies the Hadamard gate to the specified qubit in the state vector.

fn h_multi(self, qubits: &[usize]) -> Result<State, Error>

Applies the Hadamard gate to the specified qubits in the state vector in the given order.

fn ch_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

Applies the controlled Hadamard gate to the specified qubits in the state vector in the given order.

fn x(self, index: usize) -> Result<State, Error>

Applies the Pauli-X (NOT) gate to the specified qubit in the state vector.

fn x_multi(self, qubits: &[usize]) -> Result<State, Error>

Applies the Pauli-X (NOT) gate to the specified qubits in the state vector in the given order.

fn cx_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

Applies the controlled Pauli-X (NOT) gate to the specified qubits in the state vector in the given order.

fn y(self, index: usize) -> Result<State, Error>

Applies the Pauli-Y gate to the specified qubit in the state vector.

fn y_multi(self, qubits: &[usize]) -> Result<State, Error>

Applies the Pauli-Y gate to the specified qubits in the state vector in the given order.

fn cy_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

Applies the controlled Pauli-Y gate to the specified qubits in the state vector in the given order.

fn z(self, index: usize) -> Result<State, Error>

Applies the Pauli-Z gate to the specified qubit in the state vector.

fn z_multi(self, qubits: &[usize]) -> Result<State, Error>

Applies the Pauli-Z gate to the specified qubits in the state vector in the given order.

fn cz_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

Applies the controlled Pauli-Z gate to the specified qubits in the state vector in the given order.

fn i(self, qubit: usize) -> Result<State, Error>

Applies the Identity gate to the state vector.

fn i_multi(self, qubits: &[usize]) -> Result<State, Error>

Applies the Identity gate to the state vector for multiple qubits in the given order.

fn ci_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

Applies the controlled Identity gate to the state vector for multiple qubits in the given order.

fn s(self, index: usize) -> Result<State, Error>

Applies the Phase S gate to the specified qubit in the state vector.

fn s_multi(self, qubits: &[usize]) -> Result<State, Error>

Applies the Phase S gate to the specified qubits in the state vector in the given order.

fn cs_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

Applies the controlled Phase S gate to the specified qubits in the state vector in the given order.

fn t(self, index: usize) -> Result<State, Error>

Applies the Phase T gate to the specified qubit in the state vector.

fn t_multi(self, qubits: &[usize]) -> Result<State, Error>

Applies the Phase T gate to the specified qubits in the state vector in the given order.

fn ct_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

Applies the controlled Phase T gate to the specified qubits in the state vector in the given order.

fn s_dag(self, index: usize) -> Result<State, Error>

Applies the Phase S dagger gate to the specified qubit in the state vector.

fn s_dag_multi(self, qubits: &[usize]) -> Result<State, Error>

Applies the Phase S dagger gate to the specified qubits in the state vector in the given order.

fn cs_dag_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

Applies the controlled Phase S dagger gate to the specified qubits in the state vector in the given order.

fn t_dag(self, index: usize) -> Result<State, Error>

Applies the Phase T dagger gate to the specified qubit in the state vector.

fn t_dag_multi(self, qubits: &[usize]) -> Result<State, Error>

Applies the Phase T dagger gate to the specified qubits in the state vector in the given order.

fn ct_dag_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

Applies the controlled Phase T dagger gate to the specified qubits in the state vector in the given order.

fn p(self, index: usize, angle: f64) -> Result<State, Error>

Applies the Phase Shift gate with the specified angle to the given qubit.

fn p_multi(self, qubits: &[usize], angle: f64) -> Result<State, Error>

Applies the Phase Shift gate with the specified angle to the given qubits in order.

fn cp_multi( self, target_qubits: &[usize], control_qubits: &[usize], angle: f64, ) -> Result<State, Error>

Applies the controlled Phase Shift gate with the specified angle to the given qubits in order.

fn rx(self, index: usize, angle: f64) -> Result<State, Error>

Applies the RotateX gate with the specified angle to the given qubit.

fn rx_multi(self, qubits: &[usize], angle: f64) -> Result<State, Error>

Applies the RotateX gate with the specified angle to the given qubits in order.

fn crx_multi( self, target_qubits: &[usize], control_qubits: &[usize], angle: f64, ) -> Result<State, Error>

Applies the controlled RotateX gate with the specified angle to the given qubits in order.

fn ry(self, index: usize, angle: f64) -> Result<State, Error>

Applies the RotateY gate with the specified angle to the given qubit.

fn ry_multi(self, qubits: &[usize], angle: f64) -> Result<State, Error>

Applies the RotateY gate with the specified angle to the given qubits in order.

fn cry_multi( self, target_qubits: &[usize], control_qubits: &[usize], angle: f64, ) -> Result<State, Error>

Applies the controlled RotateY gate with the specified angle to the given qubits in order.

fn rz(self, index: usize, angle: f64) -> Result<State, Error>

Applies the RotateZ gate with the specified angle to the given qubit.

fn rz_multi(self, qubits: &[usize], angle: f64) -> Result<State, Error>

Applies the RotateZ gate with the specified angle to the given qubits in order.

fn crz_multi( self, target_qubits: &[usize], control_qubits: &[usize], angle: f64, ) -> Result<State, Error>

Applies the controlled RotateZ gate with the specified angle to the given qubits in order.

fn unitary( self, index: usize, unitary: [[Complex<f64>; 2]; 2], ) -> Result<State, Error>

Applies the unitary gate to the specified qubit in the state vector.

fn unitary_multi( self, qubits: &[usize], unitary: [[Complex<f64>; 2]; 2], ) -> Result<State, Error>

Applies the unitary gate to the specified qubits in the state vector in the given order.

fn cunitary_multi( self, target_qubits: &[usize], control_qubits: &[usize], unitary: [[Complex<f64>; 2]; 2], ) -> Result<State, Error>

Applies the controlled unitary gate to the specified qubits in the state vector in the given order.

fn ry_phase(self, index: usize, angle: f64, phase: f64) -> Result<State, Error>

Applies the Unitary (constructed from rotation angle and phase shift) to the specified qubit in the state vector.

fn ry_phase_multi( self, qubits: &[usize], angle: f64, phase: f64, ) -> Result<State, Error>

Applies the Unitary (constructed from rotation angle and phase shift) to the specified qubits in the state vector in the given order.

fn cry_phase_gates( self, target_qubits: &[usize], control_qubits: &[usize], angle: f64, phase: f64, ) -> Result<State, Error>

Applies the controlled Unitary (constructed from rotation angle and phase shift) to the specified qubits in the state vector in the given order.

fn ry_phase_dag( self, index: usize, angle: f64, phase: f64, ) -> Result<State, Error>

Applies the adjoint of the Unitary (constructed from rotation angle and phase shift) to the specified qubit in the state vector.

fn ry_phase_dag_multi( self, qubits: &[usize], angle: f64, phase: f64, ) -> Result<State, Error>

Applies the adjoint of the Unitary (constructed from rotation angle and phase shift) to the specified qubits in the state vector in the given order.

fn cry_phase_dag_gates( self, target_qubits: &[usize], control_qubits: &[usize], angle: f64, phase: f64, ) -> Result<State, Error>

Applies the controlled adjoint of the Unitary (constructed from rotation angle and phase shift) to the specified qubits in the state vector in the given order.

fn cnot(self, control: usize, target: usize) -> Result<State, Error>

Applies the CNOT (Controlled-NOT) gate to the state vector.

fn swap(self, qubit1: usize, qubit2: usize) -> Result<State, Error>

Applies the SWAP gate to the state vector.

fn cswap( self, target1: usize, target2: usize, controls: &[usize], ) -> Result<State, Error>

Applies the controlled SWAP gate to the state vector.

fn toffoli( self, control1: usize, control2: usize, target: usize, ) -> Result<State, Error>

Applies the Toffoli (Controlled-Controlled-NOT) gate to the state vector.

fn matchgate( self, target: usize, theta: f64, phi1: f64, phi2: f64, ) -> Result<State, Error>

Applies the Matchgate to the state vector.

fn cmatchgate( self, target: usize, theta: f64, phi1: f64, phi2: f64, controls: &[usize], ) -> Result<State, Error>

Applies the controlled Matchgate to the state vector.

fn operate( self, unitary: impl Operator, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

Applies a unitary operation to the state vector.

fn measure( self, basis: MeasurementBasis, measured_qubits: &[usize], ) -> Result<MeasurementResult, Error>

Measures the state vector in the specified basis and returns the measurement result.

fn measure_n( self, basis: MeasurementBasis, measured_qubits: &[usize], n: usize, ) -> Result<Vec<MeasurementResult>, Error>

Measures the state vector n times in the specified basis and returns the measurement results.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl ChainableState for Result<State, Error>

fn h(self, index: usize) -> Result<State, Error>

fn h_multi(self, qubits: &[usize]) -> Result<State, Error>

fn ch_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

fn x(self, index: usize) -> Result<State, Error>

fn x_multi(self, qubits: &[usize]) -> Result<State, Error>

fn cx_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

fn y(self, index: usize) -> Result<State, Error>

fn y_multi(self, qubits: &[usize]) -> Result<State, Error>

fn cy_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

fn z(self, index: usize) -> Result<State, Error>

fn z_multi(self, qubits: &[usize]) -> Result<State, Error>

fn cz_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

fn i(self, qubit: usize) -> Result<State, Error>

fn i_multi(self, qubits: &[usize]) -> Result<State, Error>

fn ci_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

fn s(self, index: usize) -> Result<State, Error>

fn s_multi(self, qubits: &[usize]) -> Result<State, Error>

fn cs_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

fn t(self, index: usize) -> Result<State, Error>

fn t_multi(self, qubits: &[usize]) -> Result<State, Error>

fn ct_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

fn s_dag(self, index: usize) -> Result<State, Error>

fn s_dag_multi(self, qubits: &[usize]) -> Result<State, Error>

fn cs_dag_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

fn t_dag(self, index: usize) -> Result<State, Error>

fn t_dag_multi(self, qubits: &[usize]) -> Result<State, Error>

fn ct_dag_multi( self, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

fn p(self, index: usize, angle: f64) -> Result<State, Error>

fn p_multi(self, qubits: &[usize], angle: f64) -> Result<State, Error>

fn cp_multi( self, target_qubits: &[usize], control_qubits: &[usize], angle: f64, ) -> Result<State, Error>

fn rx(self, index: usize, angle: f64) -> Result<State, Error>

fn rx_multi(self, qubits: &[usize], angle: f64) -> Result<State, Error>

fn crx_multi( self, target_qubits: &[usize], control_qubits: &[usize], angle: f64, ) -> Result<State, Error>

fn ry(self, index: usize, angle: f64) -> Result<State, Error>

fn ry_multi(self, qubits: &[usize], angle: f64) -> Result<State, Error>

fn cry_multi( self, target_qubits: &[usize], control_qubits: &[usize], angle: f64, ) -> Result<State, Error>

fn rz(self, index: usize, angle: f64) -> Result<State, Error>

fn rz_multi(self, qubits: &[usize], angle: f64) -> Result<State, Error>

fn crz_multi( self, target_qubits: &[usize], control_qubits: &[usize], angle: f64, ) -> Result<State, Error>

fn unitary( self, index: usize, unitary: [[Complex<f64>; 2]; 2], ) -> Result<State, Error>

fn unitary_multi( self, qubits: &[usize], unitary: [[Complex<f64>; 2]; 2], ) -> Result<State, Error>

fn cunitary_multi( self, target_qubits: &[usize], control_qubits: &[usize], unitary: [[Complex<f64>; 2]; 2], ) -> Result<State, Error>

fn ry_phase(self, index: usize, angle: f64, phase: f64) -> Result<State, Error>

fn ry_phase_multi( self, qubits: &[usize], angle: f64, phase: f64, ) -> Result<State, Error>

fn cry_phase_gates( self, target_qubits: &[usize], control_qubits: &[usize], angle: f64, phase: f64, ) -> Result<State, Error>

fn ry_phase_dag( self, index: usize, angle: f64, phase: f64, ) -> Result<State, Error>

fn ry_phase_dag_multi( self, qubits: &[usize], angle: f64, phase: f64, ) -> Result<State, Error>

fn cry_phase_dag_gates( self, target_qubits: &[usize], control_qubits: &[usize], angle: f64, phase: f64, ) -> Result<State, Error>

fn cnot(self, control: usize, target: usize) -> Result<State, Error>

fn swap(self, qubit1: usize, qubit2: usize) -> Result<State, Error>

fn cswap( self, target1: usize, target2: usize, controls: &[usize], ) -> Result<State, Error>

fn toffoli( self, control1: usize, control2: usize, target: usize, ) -> Result<State, Error>

fn matchgate( self, target: usize, theta: f64, phi1: f64, phi2: f64, ) -> Result<State, Error>

fn cmatchgate( self, target: usize, theta: f64, phi1: f64, phi2: f64, controls: &[usize], ) -> Result<State, Error>

fn operate( self, unitary: impl Operator, target_qubits: &[usize], control_qubits: &[usize], ) -> Result<State, Error>

fn measure( self, basis: MeasurementBasis, measured_qubits: &[usize], ) -> Result<MeasurementResult, Error>

fn measure_n( self, basis: MeasurementBasis, measured_qubits: &[usize], n: usize, ) -> Result<Vec<MeasurementResult>, Error>

Implementors