CRTP defined class for simulator implementations. More...

#include <Simulator.hpp>

Inheritance diagram for QNLP::SimulatorGeneral< DerivedType >:

Collaboration diagram for QNLP::SimulatorGeneral< DerivedType >:

Public Member Functions
virtual	~SimulatorGeneral ()
	Destroy the Simulator General object. More...

void	applyGateX (std::size_t qubit_idx)
	Apply the Pauli X gate to the given qubit. More...

void	applyGateY (std::size_t qubit_idx)
	Apply the Pauli Y gate to the given qubit. More...

void	applyGateZ (std::size_t qubit_idx)
	Apply the Pauli Z gate to the given qubit. More...

void	applyGateI (std::size_t qubit_idx)
	Apply the Identity gate to the given qubit. More...

void	applyGateH (std::size_t qubit_idx)
	Apply the Hadamard gate to the given qubit. More...

void	applyGateSqrtX (std::size_t qubit_idx)
	Apply the Sqrt{Pauli X} gate to the given qubit. More...

void	applyGateRotX (std::size_t qubit_idx, double angle_rad)
	Apply the given Rotation about X-axis to the given qubit. More...

void	applyGateRotY (std::size_t qubit_idx, double angle_rad)
	Apply the given Rotation about Y-axis to the given qubit. More...

void	applyGateRotZ (std::size_t qubit_idx, double angle_rad)
	Apply the given Rotation about Z-axis to the given qubit. More...

template<class Mat2x2Type >
void	applyGateU (const Mat2x2Type &U, std::size_t qubit_idx)
	Apply arbitrary user-defined unitary gate to qubit at qubit_idx. More...

decltype(auto)	getGateX ()
	Get the Pauli-X gate; returns templated type GateType. More...

decltype(auto)	getGateY ()
	Get the Pauli-Y gate; must be overloaded with appropriate return type. More...

decltype(auto)	getGateZ ()
	Get the Pauli-Z gate; must be overloaded with appropriate return type. More...

decltype(auto)	getGateI ()
	Get the Identity; must be overloaded with appropriate return type. More...

decltype(auto)	getGateH ()
	Get the Hadamard gate; must be overloaded with appropriate return type. More...

template<class Mat2x2Type >
void	applyGateCU (const Mat2x2Type &U, const std::size_t control, const std::size_t target, std::string label="CU")
	Apply the given controlled unitary gate on target qubit. More...

void	applyGateCX (const std::size_t control, const std::size_t target)
	Apply Controlled Pauli-X (CNOT) on target qubit. More...

void	applyGateCY (const std::size_t control, const std::size_t target)
	Apply Controlled Pauli-Y on target qubit. More...

void	applyGateCZ (const std::size_t control, const std::size_t target)
	Apply Controlled Pauli-Z on target qubit. More...

void	applyGateCH (const std::size_t control, const std::size_t target)
	Apply Controlled Hadamard on target qubit. More...

void	applyGateSwap (std::size_t qubit_idx0, std::size_t qubit_idx1)
	Swap the qubits at the given indices. More...

void	applyGateSqrtSwap (std::size_t qubit_idx0, std::size_t qubit_idx1)
	Performs Sqrt SWAP gate between two given qubits (half way SWAP) More...

void	applyGatePhaseShift (double angle, std::size_t qubit_idx)
	Apply phase shift to given Qubit; [[1 0] [0 exp(i*angle)]]. More...

void	applyGateCPhaseShift (double angle, std::size_t control, std::size_t target)
	Perform controlled phase shift gate. More...

void	applyGateCCX (std::size_t ctrl_qubit0, std::size_t ctrl_qubit1, std::size_t target_qubit)
	Controlled controlled NOT (CCNOT, CCX) gate. More...

void	applyGateCSwap (std::size_t ctrl_qubit, std::size_t qubit_swap0, std::size_t qubit_swap1)
	Controlled SWAP gate. More...

void	applyGateCRotX (std::size_t ctrl_qubit, std::size_t qubit_idx, double angle_rad)
	Apply the given Controlled Rotation about X-axis to the given qubit. More...

void	applyGateCRotY (std::size_t ctrl_qubit, std::size_t qubit_idx, double angle_rad)
	Apply the given Controlled Rotation about Y-axis to the given qubit. More...

void	applyGateCRotZ (std::size_t ctrl_qubit, std::size_t qubit_idx, double angle_rad)
	Apply the given Controlled Rotation about Z-axis to the given qubit. More...

decltype(auto)	getQubitRegister ()
	Get the underlying qubit register object. More...

std::size_t	getNumQubits ()
	Get the number of Qubits. More...

void	applyQFT (std::size_t minIdx, std::size_t maxIdx)
	Apply the forward Quantum Fourier transform (QFT) to the given register index range. More...

void	applyIQFT (std::size_t minIdx, std::size_t maxIdx)
	Apply the inverse Quantum Fourier transform (IQFT) to the given register index range. More...

void	sumReg (std::size_t r0_minIdx, std::size_t r0_maxIdx, std::size_t r1_minIdx, std::size_t r1_maxIdx)
	Applies \|r1>\|r2> -> \|r1>\|r1+r2> More...

void	subReg (std::size_t r0_minIdx, std::size_t r0_maxIdx, std::size_t r1_minIdx, std::size_t r1_maxIdx)
	Applies \|r1>\|r2> -> \|r1>\|r1-r2> More...

template<class Mat2x2Type >
void	applyGateNCU (const Mat2x2Type &U, const std::vector< std::size_t > &ctrlIndices, std::size_t target, std::string label)
	Apply n-control unitary gate to the given qubit target. More...

template<class Mat2x2Type >
void	applyGateNCU (const Mat2x2Type &U, const std::vector< std::size_t > &ctrlIndices, const std::vector< std::size_t > &auxIndices, std::size_t target, std::string label)
	Apply n-control sigma_x gate to the given qubit target, using auxiliary qubits for 5CX optimisation. More...

template<class Mat2x2Type >
void	applyOracleU (std::size_t bit_pattern, const std::vector< std::size_t > &ctrlIndices, std::size_t target, const Mat2x2Type &U, std::string gateLabel)
	Apply oracle to match given binary index with non adjacent controls. More...

template<class Mat2x2Type >
void	applyOracleU (std::size_t bit_pattern, const std::vector< std::size_t > &ctrlIndices, const std::vector< std::size_t > &auxIndices, std::size_t target, const Mat2x2Type &U, std::string gateLabel)
	Apply oracle to match given binary index with non adjacent controls. More...

void	applyOraclePhase (std::size_t bit_pattern, const std::vector< std::size_t > &ctrlIndices, std::size_t target)
	Apply oracle to match given binary index with linearly adjacent controls. More...

void	applyDiffusion (const std::vector< std::size_t > &ctrlIndices, std::size_t target)
	Apply diffusion operator on marked state. More...

void	encodeToRegister (std::size_t target_pattern, const std::vector< std::size_t > target_register, std::size_t len_bin_pattern)
	Encodes a defined binary pattern into a defined target register (initially in state \|00...0>) of all quantum states in the superposition. More...

void	encodeBinToSuperpos_unique (const std::vector< std::size_t > &reg_memory, const std::vector< std::size_t > &reg_auxiliary, const std::vector< std::size_t > &bin_patterns, const std::size_t len_bin_pattern)
	Encode inputted binary strings to the memory register specified as a superposition of states. Note that this implementation does not allow for multiple instances of the same input pattern but allows for 0 to be encoded. More...

void	applyHammingDistanceRotY (std::size_t test_pattern, const std::vector< std::size_t > reg_mem, const std::vector< std::size_t > reg_auxiliary, std::size_t len_bin_pattern)
	Computes the relative Hamming distance between the test pattern and the pattern stored in each state of the superposition, storing the result in the amplitude of the corresponding state. More...

void	applyHammingDistanceOverwrite (std::size_t test_pattern, const std::vector< std::size_t > reg_mem, const std::vector< std::size_t > reg_auxiliary, std::size_t len_bin_pattern)
	Computes the relative Hamming distance between the test pattern and the pattern stored in each state of the superposition, overwriting the aux register pattern with the resulting bit differences. More...

bool	applyMeasurement (std::size_t target, bool normalize=true)
	Apply measurement to a target qubit, randomly collapsing the qubit proportional to the amplitude and returns the collapsed value. More...

std::size_t	applyMeasurementToRegister (std::vector< std::size_t > target_qubits, bool normalize=true)
	Apply measurement to a set of target qubits, randomly collapsing the qubits proportional to the amplitude and returns the bit string of the qubits in the order they are represented in the vector of indexes, in the form of an unsigned integer. More...

void	groupQubits (const std::vector< std::size_t > reg_auxiliary, bool lsb=true)
	Group all set qubits to MSB in register (ie \|010100> -> \|000011>) More...

void	collapseToBasisZ (std::size_t target, bool collapseValue)
	Apply measurement to a target qubit with respect to the Z-basis, collapsing to a specified value (0 or 1). Amplitudes are r-normalized afterwards. More...

void	initRegister ()
	(Re)Initialise the underlying register of the encapsulated simulator to well-defined state (\|0....0>) More...

void	initCaches ()
	Initialise caches used in NCU operation. More...

template<class Mat2x2Type >
void	addUToCache (std::string gateLabel, const Mat2x2Type &U)
	Adds a matrix to the cache, assigning it to a defined label. This is used in the caching for the NCU operation. More...

void	PrintStates (std::string x, std::vector< std::size_t > qubits={})
	Prints the string x and then for each state of the specified qubits in the superposition, prints each its amplitude, followed by state and then by the probability of that state. Note that this state observation method is not a permitted quantum operation, however it is provided for convenience and debugging/testing. More...

template<class Mat2x2Type >
Mat2x2Type	matrixSqrt (const Mat2x2Type &U)
	Calculates the unitary matrix square root (U == VV, where V is returned) More...

void	InvertRegister (const unsigned int minIdx, const unsigned int maxIdx)
	Invert the register about the given indides: 0,1,2...n-1,n -> n,n-1,...,1,0. More...

Static Public Member Functions
template<class Mat2x2Type >
static Mat2x2Type	adjointMatrix (const Mat2x2Type &U)
	Function to calculate the adjoint of an input matrix. More...

Protected Attributes
std::any	sim_ncu

Private Member Functions
	SimulatorGeneral ()
	Construct a new Simulator General object. More...

Private Attributes
friend	DerivedType

Detailed Description

template<class DerivedType>
class QNLP::SimulatorGeneral< DerivedType >

CRTP defined class for simulator implementations.

Template Parameters

DerivedType CRTP derived class simulator type

Definition at line 69 of file Simulator.hpp.

Constructor & Destructor Documentation

◆ SimulatorGeneral()

template<class DerivedType>

QNLP::SimulatorGeneral< DerivedType >::SimulatorGeneral ( )

inlineprivate

Construct a new Simulator General object.

Definition at line 77 of file Simulator.hpp.

                       { 
     //If we are building MPI support, ensure that it is init'd here before subclasses.
     #ifdef ENABLE_MPI
         int mpi_is_init;
         MPI_Initialized(&mpi_is_init);
         if (! mpi_is_init){
             int argc_tmp = 0;
             char** argv_tmp = new char*[argc_tmp];
             MPI_Init(&argc_tmp, &argv_tmp);
             delete argv_tmp;
         }
     #endif
 
         sim_ncu =  NCU<DerivedType>(static_cast<DerivedType&>(*this));
     }; 

◆ ~SimulatorGeneral()

template<class DerivedType>

virtual QNLP::SimulatorGeneral< DerivedType >::~SimulatorGeneral ( )

inlinevirtual

Destroy the Simulator General object.

Definition at line 113 of file Simulator.hpp.

113 { }

Member Function Documentation

◆ addUToCache()

template<class DerivedType>

template<class Mat2x2Type >

void QNLP::SimulatorGeneral< DerivedType >::addUToCache	(	std::string	gateLabel,
		const Mat2x2Type &	U
	)

inline

Adds a matrix to the cache, assigning it to a defined label. This is used in the caching for the NCU operation.

Template Parameters

Mat2x2Type Matrix type to be cached

Parameters

gateLabel	Label assigned to the matrix being cached
U	Matrix to be cached

Definition at line 703 of file Simulator.hpp.

                                                                   {
             #if defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER)
             std::experimental::any_cast<NCU<DerivedType>&>(sim_ncu).getGateCache().addToCache(static_cast<DerivedType&>(*this), gateLabel, U, 16);
             #else
             std::any_cast<NCU<DerivedType>&>(sim_ncu).getGateCache().addToCache(static_cast<DerivedType&>(*this), gateLabel, U, 16);
             #endif
         }

◆ adjointMatrix()

template<class DerivedType>

template<class Mat2x2Type >

static Mat2x2Type QNLP::SimulatorGeneral< DerivedType >::adjointMatrix ( const Mat2x2Type & U )

inlinestatic

Function to calculate the adjoint of an input matrix.

Template Parameters

Mat2x2Type Matrix type

Parameters

U	Unitary matrix to be adjointed

Returns: openqu::TinyMatrix<Type, 2, 2, 32> U^{\dagger}

Definition at line 757 of file Simulator.hpp.

                                                             {
             Mat2x2Type Uadjoint(U);
             std::complex<double> tmp;
             tmp = Uadjoint(0,1);
             Uadjoint(0,1) = Uadjoint(1,0);
             Uadjoint(1,0) = tmp;
             Uadjoint(0,0) = std::conj(Uadjoint(0,0));
             Uadjoint(0,1) = std::conj(Uadjoint(0,1));
             Uadjoint(1,0) = std::conj(Uadjoint(1,0));
             Uadjoint(1,1) = std::conj(Uadjoint(1,1));
             return Uadjoint;
         }

◆ applyDiffusion()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyDiffusion	(	const std::vector< std::size_t > &	ctrlIndices,
		std::size_t	target
	)

inline

Apply diffusion operator on marked state.

Parameters

ctrlIndices	Vector of control line indices
target	Target qubit index to apply Ctrl-Z upon.

Definition at line 536 of file Simulator.hpp.

                                                                                       {
             Diffusion<DerivedType> diffusion;
             diffusion.applyOpDiffusion(static_cast<DerivedType&>(*this), ctrlIndices, target);
         }

◆ applyGateCCX()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateCCX	(	std::size_t	ctrl_qubit0,
		std::size_t	ctrl_qubit1,
		std::size_t	target_qubit
	)

inline

Controlled controlled NOT (CCNOT, CCX) gate.

Parameters

ctrl_qubit0	Control qubit 0
ctrl_qubit1	Control qubit 1
target_qubit	Target qubit

Definition at line 346 of file Simulator.hpp.

                                                                                                {
             static_cast<DerivedType*>(this)->applyGateCCX(ctrl_qubit0, ctrl_qubit1, target_qubit);
         }

◆ applyGateCH()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateCH	(	const std::size_t	control,
		const std::size_t	target
	)

inline

Apply Controlled Hadamard on target qubit.

Parameters

control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 294 of file Simulator.hpp.

                                                                          {
             static_cast<DerivedType*>(this)->applyGateCH(control, target);
         }

◆ applyGateCPhaseShift()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateCPhaseShift	(	double	angle,
		std::size_t	control,
		std::size_t	target
	)

inline

Perform controlled phase shift gate.

Parameters

angle	Angle of phase shift in rads
control	Index of control qubit
target	Index of target qubit

Definition at line 335 of file Simulator.hpp.

                                                                                     {
             static_cast<DerivedType*>(this)->applyGateCPhaseShift(angle, control, target);
         }

◆ applyGateCRotX()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateCRotX	(	std::size_t	ctrl_qubit,
		std::size_t	qubit_idx,
		double	angle_rad
	)

inline

Apply the given Controlled Rotation about X-axis to the given qubit.

Parameters

ctrl_qubit	Control qubit
qubit_idx	Index of qubit to rotate about X-axis
angle_rad	Rotation angle

Definition at line 373 of file Simulator.hpp.

                                                                                         {
             static_cast<DerivedType&>(*this).applyGateCRotX(ctrl_qubit, qubit_idx, angle_rad);
         }

◆ applyGateCRotY()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateCRotY	(	std::size_t	ctrl_qubit,
		std::size_t	qubit_idx,
		double	angle_rad
	)

inline

Apply the given Controlled Rotation about Y-axis to the given qubit.

Parameters

ctrl_qubit	Control qubit
qubit_idx	Index of qubit to rotate about Y-axis
angle_rad	Rotation angle

Definition at line 384 of file Simulator.hpp.

                                                                                         {
             static_cast<DerivedType&>(*this).applyGateCRotY(ctrl_qubit, qubit_idx, angle_rad);
         }

◆ applyGateCRotZ()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateCRotZ	(	std::size_t	ctrl_qubit,
		std::size_t	qubit_idx,
		double	angle_rad
	)

inline

Apply the given Controlled Rotation about Z-axis to the given qubit.

Parameters

ctrl_qubit	Control qubit
qubit_idx	Index of qubit to rotate about Z-axis
angle_rad	Rotation angle

Definition at line 395 of file Simulator.hpp.

                                                                                         {
             static_cast<DerivedType&>(*this).applyGateCRotZ(ctrl_qubit, qubit_idx, angle_rad);
         }

◆ applyGateCSwap()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateCSwap	(	std::size_t	ctrl_qubit,
		std::size_t	qubit_swap0,
		std::size_t	qubit_swap1
	)

inline

Controlled SWAP gate.

Parameters

ctrl_qubit	Control qubit
qubit_swap0	Swap qubit 0
qubit_swap1	Swap qubit 1

Definition at line 357 of file Simulator.hpp.

                                                                                                {
             assert( static_cast<DerivedType*>(this)->getNumQubits() > 2 );
             //The requested qubit indices must be available to use within the register range
             assert( (ctrl_qubit < getNumQubits() ) && (qubit_swap0 < getNumQubits() ) && (qubit_swap1 < getNumQubits()) );
             //The qubits must be different from one another
             assert( ctrl_qubit != qubit_swap0 && ctrl_qubit != qubit_swap1 && qubit_swap0 != qubit_swap1 );
             static_cast<DerivedType*>(this)->applyGateCSwap(ctrl_qubit, qubit_swap0, qubit_swap1);
         }

◆ applyGateCU()

template<class DerivedType>

template<class Mat2x2Type >

void QNLP::SimulatorGeneral< DerivedType >::applyGateCU	(	const Mat2x2Type &	U,
		const std::size_t	control,
		const std::size_t	target,
		std::string	label = `"CU"`
	)

inline

Apply the given controlled unitary gate on target qubit.

Parameters

U	User-defined arbitrary 2x2 unitary gate (matrix)
control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 254 of file Simulator.hpp.

                                                                                                                     {
             static_cast<DerivedType*>(this)->applyGateCU(U, control, target, label);
         }

◆ applyGateCX()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateCX	(	const std::size_t	control,
		const std::size_t	target
	)

inline

Apply Controlled Pauli-X (CNOT) on target qubit.

Parameters

control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 264 of file Simulator.hpp.

                                                                          {
             static_cast<DerivedType*>(this)->applyGateCX(control, target);
         }

◆ applyGateCY()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateCY	(	const std::size_t	control,
		const std::size_t	target
	)

inline

Apply Controlled Pauli-Y on target qubit.

Parameters

control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 274 of file Simulator.hpp.

                                                                          {
             static_cast<DerivedType*>(this)->applyGateCY(control, target);
         }

◆ applyGateCZ()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateCZ	(	const std::size_t	control,
		const std::size_t	target
	)

inline

Apply Controlled Pauli-Z on target qubit.

Parameters

control	Qubit index acting as control
target	Qubit index acting as target

Definition at line 284 of file Simulator.hpp.

                                                                          {
             static_cast<DerivedType*>(this)->applyGateCZ(control, target);
         }

◆ applyGateH()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateH ( std::size_t qubit_idx )

inline

Apply the Hadamard gate to the given qubit.

Parameters

qubit_idx

Definition at line 155 of file Simulator.hpp.

                                             {
             static_cast<DerivedType&>(*this).applyGateH(qubit_idx);
         }

◆ applyGateI()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateI ( std::size_t qubit_idx )

inline

Apply the Identity gate to the given qubit.

Parameters

qubit_idx

Definition at line 147 of file Simulator.hpp.

                                             {
             static_cast<DerivedType&>(*this).applyGateI(qubit_idx); 
         }

◆ applyGateNCU() [1/2]

template<class DerivedType>

template<class Mat2x2Type >

void QNLP::SimulatorGeneral< DerivedType >::applyGateNCU	(	const Mat2x2Type &	U,
		const std::vector< std::size_t > &	ctrlIndices,
		std::size_t	target,
		std::string	label
	)

inline

Apply n-control unitary gate to the given qubit target.

Template Parameters

Mat2x2Type 2x2 Matrix type of unitary gate in the format expected by the derived simulator object; decltype(simulator.getGateX()) can be used in template

Parameters

U	2x2 unitary matrix
ctrlIndices	Vector of the control lines for NCU operation
target	Target qubit index to apply nCU
label	Gate label string (U, X, Y, etc.)

Definition at line 462 of file Simulator.hpp.

                                                                                                                           {
             #if defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER)
             std::experimental::any_cast<NCU<DerivedType>&>(sim_ncu).applyNQubitControl(static_cast<DerivedType&>(*this), ctrlIndices, {}, target, label, U, 0);
             #else
             std::any_cast<NCU<DerivedType>&>(sim_ncu).applyNQubitControl(static_cast<DerivedType&>(*this), ctrlIndices, {}, target, label, U, 0);
             #endif
         }

◆ applyGateNCU() [2/2]

template<class DerivedType>

template<class Mat2x2Type >

void QNLP::SimulatorGeneral< DerivedType >::applyGateNCU	(	const Mat2x2Type &	U,
		const std::vector< std::size_t > &	ctrlIndices,
		const std::vector< std::size_t > &	auxIndices,
		std::size_t	target,
		std::string	label
	)

inline

Apply n-control sigma_x gate to the given qubit target, using auxiliary qubits for 5CX optimisation.

Template Parameters

Mat2x2Type 2x2 Matrix type of unitary gate in the format expected by the derived simulator object; decltype(simulator.getGateX()) can be used in template

Parameters

U	2x2 unitary matrix
minIdx	Lowest index of the control lines expected for nCU
maxIdx	Highest index of the control lines expected for the nCU
target	Target qubit index to apply nCU

Definition at line 480 of file Simulator.hpp.

                                                                                                                                                                   {
             #if defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER)
             std::experimental::any_cast<NCU<DerivedType>&>(sim_ncu).applyNQubitControl(static_cast<DerivedType&>(*this), ctrlIndices, auxIndices, target, label, U, 0);
             #else
             std::any_cast<NCU<DerivedType>&>(sim_ncu).applyNQubitControl(static_cast<DerivedType&>(*this), ctrlIndices, auxIndices, target, label, U, 0);
             #endif
         }

◆ applyGatePhaseShift()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGatePhaseShift	(	double	angle,
		std::size_t	qubit_idx
	)

inline

Apply phase shift to given Qubit; [[1 0] [0 exp(i*angle)]].

Parameters

angle	Angle of phase shift in rads
qubit_idx	Qubit index to perform phase shift upon

Definition at line 324 of file Simulator.hpp.

                                                                    {
             static_cast<DerivedType*>(this)->applyGatePhaseShift(angle, qubit_idx);
         }

◆ applyGateRotX()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateRotX	(	std::size_t	qubit_idx,
		double	angle_rad
	)

inline

Apply the given Rotation about X-axis to the given qubit.

Parameters

qubit_idx	Index of qubit to rotate about X-axis
angle_rad	Rotation angle

Definition at line 172 of file Simulator.hpp.

                                                                  {
             static_cast<DerivedType&>(*this).applyGateRotX(qubit_idx, angle_rad);
         }

◆ applyGateRotY()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateRotY	(	std::size_t	qubit_idx,
		double	angle_rad
	)

inline

Apply the given Rotation about Y-axis to the given qubit.

Parameters

qubit_idx	Index of qubit to rotate about Y-axis
angle_rad	Rotation angle

Definition at line 181 of file Simulator.hpp.

                                                                  {
             static_cast<DerivedType&>(*this).applyGateRotY(qubit_idx, angle_rad);
         }

◆ applyGateRotZ()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateRotZ	(	std::size_t	qubit_idx,
		double	angle_rad
	)

inline

Apply the given Rotation about Z-axis to the given qubit.

Parameters

qubit_idx	Index of qubit to rotate about Z-axis
angle_rad	Rotation angle

Definition at line 190 of file Simulator.hpp.

                                                                  {
             static_cast<DerivedType&>(*this).applyGateRotZ(qubit_idx, angle_rad);
         }

◆ applyGateSqrtSwap()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateSqrtSwap	(	std::size_t	qubit_idx0,
		std::size_t	qubit_idx1
	)

inline

Performs Sqrt SWAP gate between two given qubits (half way SWAP)

Parameters

qubit_idx0	Qubit index 0
qubit_idx1	Qubit index 1

Definition at line 314 of file Simulator.hpp.

                                                                           {
             static_cast<DerivedType*>(this)->applyGateSqrtSwap(qubit_idx0,qubit_idx1);
         }

◆ applyGateSqrtX()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateSqrtX ( std::size_t qubit_idx )

inline

Apply the Sqrt{Pauli X} gate to the given qubit.

Parameters

qubit_idx

Definition at line 163 of file Simulator.hpp.

                                                 {
             static_cast<DerivedType&>(*this).applyGateSqrtX(qubit_idx);
         }

◆ applyGateSwap()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateSwap	(	std::size_t	qubit_idx0,
		std::size_t	qubit_idx1
	)

inline

Swap the qubits at the given indices.

Parameters

qubit_idx0	Index of qubit 0 to swap &(0 -> 1)
qubit_idx1	Index of qubit 1 to swap &(1 -> 0)

Definition at line 304 of file Simulator.hpp.

                                                                       {
             static_cast<DerivedType*>(this)->applyGateSwap(qubit_idx0,qubit_idx1);
         }

Referenced by QNLP::SimulatorGeneral< IntelSimulator >::InvertRegister().

Here is the caller graph for this function:

◆ applyGateU()

template<class DerivedType>

template<class Mat2x2Type >

void QNLP::SimulatorGeneral< DerivedType >::applyGateU	(	const Mat2x2Type &	U,
		std::size_t	qubit_idx
	)

inline

Apply arbitrary user-defined unitary gate to qubit at qubit_idx.

Parameters

U	User-defined unitary 2x2 matrix of templated type Mat2x2Type
qubit_idx	Index of qubit to apply gate upon

Definition at line 201 of file Simulator.hpp.

                                                                  {
             static_cast<DerivedType*>(this)->applyGateU(U, qubit_idx);
         }

◆ applyGateX()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateX ( std::size_t qubit_idx )

inline

Apply the Pauli X gate to the given qubit.

Parameters

qubit_idx

Definition at line 123 of file Simulator.hpp.

                                             { 
             static_cast<DerivedType&>(*this).applyGateX(qubit_idx);
         };

Referenced by QNLP::SimulatorGeneral< IntelSimulator >::encodeToRegister().

Here is the caller graph for this function:

◆ applyGateY()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateY ( std::size_t qubit_idx )

inline

Apply the Pauli Y gate to the given qubit.

Parameters

qubit_idx

Definition at line 131 of file Simulator.hpp.

                                             {
             static_cast<DerivedType&>(*this).applyGateY(qubit_idx);
         }

◆ applyGateZ()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyGateZ ( std::size_t qubit_idx )

inline

Apply the Pauli Z gate to the given qubit.

Parameters

qubit_idx

Definition at line 139 of file Simulator.hpp.

                                             {
             static_cast<DerivedType&>(*this).applyGateZ(qubit_idx);
         }

◆ applyHammingDistanceOverwrite()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyHammingDistanceOverwrite	(	std::size_t	test_pattern,
		const std::vector< std::size_t >	reg_mem,
		const std::vector< std::size_t >	reg_auxiliary,
		std::size_t	len_bin_pattern
	)

inline

Computes the relative Hamming distance between the test pattern and the pattern stored in each state of the superposition, overwriting the aux register pattern with the resulting bit differences.

Parameters

test_pattern	The binary pattern used as the the basis for the Hamming Distance.
reg_mem	Vector containing the indices of the register qubits that contain the training patterns.
reg_auxiliary	Vector containing the indices of the register qubits which the first len_bin_pattern qubits will store the test_pattern.

Definition at line 609 of file Simulator.hpp.

                                           {
 
             assert(reg_mem.size() < reg_auxiliary.size()-1);
 
             // Encode test pattern to auxiliary register
             encodeToRegister(test_pattern, reg_auxiliary, len_bin_pattern);
 
             HammingDistance<DerivedType>::computeHammingDistanceOverwriteAux(static_cast<DerivedType&>(*this), reg_mem, reg_auxiliary);
         }

◆ applyHammingDistanceRotY()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyHammingDistanceRotY	(	std::size_t	test_pattern,
		const std::vector< std::size_t >	reg_mem,
		const std::vector< std::size_t >	reg_auxiliary,
		std::size_t	len_bin_pattern
	)

inline

Computes the relative Hamming distance between the test pattern and the pattern stored in each state of the superposition, storing the result in the amplitude of the corresponding state.

Parameters

test_pattern	The binary pattern used as the the basis for the Hamming Distance.
reg_mem	Vector containing the indices of the register qubits that contain the training patterns.
reg_auxiliary	Vector containing the indices of the register qubits which the first len_bin_pattern qubits will store the test_pattern.
len_bin_pattern	Length of the binary patterns

Definition at line 584 of file Simulator.hpp.

                                           {
 
             assert(len_bin_pattern < reg_auxiliary.size()-1);
 
             // Encode test pattern to auxiliary register
             encodeToRegister(test_pattern, reg_auxiliary, len_bin_pattern);
 
             HammingDistance<DerivedType> hamming_operator(len_bin_pattern);
             hamming_operator.computeHammingDistanceRotY(static_cast<DerivedType&>(*this), reg_mem, reg_auxiliary, len_bin_pattern);
 
             // Un-encode test pattern from auxiliary register
             encodeToRegister(test_pattern, reg_auxiliary, len_bin_pattern);
         }

◆ applyIQFT()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyIQFT	(	std::size_t	minIdx,
		std::size_t	maxIdx
	)

inline

Apply the inverse Quantum Fourier transform (IQFT) to the given register index range.

Parameters

minIdx	Lowest qubit index of the IQFT range
maxIdx	Highest qubit index of the IQFT range

Definition at line 433 of file Simulator.hpp.

                                                           {
             QFT<decltype(static_cast<DerivedType&>(*this))>::applyIQFT(static_cast<DerivedType&>(*this), minIdx, maxIdx);
         }

Referenced by QNLP::SimulatorGeneral< IntelSimulator >::applyIQFT().

Here is the caller graph for this function:

◆ applyMeasurement()

template<class DerivedType>

bool QNLP::SimulatorGeneral< DerivedType >::applyMeasurement	(	std::size_t	target,
		bool	normalize = `true`
	)

inline

Apply measurement to a target qubit, randomly collapsing the qubit proportional to the amplitude and returns the collapsed value.

Returns: bool Value that qubit is randomly collapsed to

Parameters

target	The index of the qubit being collapsed
normalize	Optional argument specifying whether amplitudes shoud be normalized (true) or not (false). Default value is true.

Definition at line 629 of file Simulator.hpp.

                                                                     {
             return static_cast<DerivedType*>(this)->applyMeasurement(target, normalize);
         }

◆ applyMeasurementToRegister()

template<class DerivedType>

std::size_t QNLP::SimulatorGeneral< DerivedType >::applyMeasurementToRegister	(	std::vector< std::size_t >	target_qubits,
		bool	normalize = `true`
	)

inline

Apply measurement to a set of target qubits, randomly collapsing the qubits proportional to the amplitude and returns the bit string of the qubits in the order they are represented in the vector of indexes, in the form of an unsigned integer.

Returns: std::size_t Integer representing the binary string of the collapsed qubits, ordered by least significant digit corresponding to first qubit in target vector of indices

Parameters

target_qubits	Vector of indices of qubits being collapsed
normalize	Optional argument specifying whether amplitudes shoud be normalized (true) or not (false). Default value is true.

Definition at line 640 of file Simulator.hpp.

                                                                                                      {
             // Store current state of training register in it's integer format
             std::size_t val = 0; 
             for(int j = target_qubits.size() - 1; j > -1; j--){
                 val |= (static_cast<DerivedType*>(this)->applyMeasurement(target_qubits[j], normalize) << j);
             } 
             return val;
         }

◆ applyOraclePhase()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyOraclePhase	(	std::size_t	bit_pattern,
		const std::vector< std::size_t > &	ctrlIndices,
		std::size_t	target
	)

inline

Apply oracle to match given binary index with linearly adjacent controls.

Parameters

bit_pattern	Oracle pattern in binary
ctrlIndices	Control lines for oracle
target	Target qubit index to apply Z gate upon

Definition at line 524 of file Simulator.hpp.

                                                                                                                {
             //applyOracleU<decltype(static_cast<DerivedType*>(this)->getGateZ())>(bit_pattern, ctrlIndices, target, static_cast<DerivedType*>(this)->getGateZ());
             Oracle<DerivedType> oracle;
             oracle.bitStringPhaseOracle(static_cast<DerivedType&>(*this), bit_pattern, ctrlIndices, target );
         }

◆ applyOracleU() [1/2]

template<class DerivedType>

template<class Mat2x2Type >

void QNLP::SimulatorGeneral< DerivedType >::applyOracleU	(	std::size_t	bit_pattern,
		const std::vector< std::size_t > &	ctrlIndices,
		std::size_t	target,
		const Mat2x2Type &	U,
		std::string	gateLabel
	)

inline

Apply oracle to match given binary index with non adjacent controls.

Parameters

bit_pattern	Oracle state pattern (bitstring: 0-> \|0>, 1-> \|1>)
U	2x2 unitary matrix to apply
ctrlIndices	Control indices for operation
target	Target qubit index to apply U on
gateLabel	Label used to access required cached matrix for NCU

Definition at line 498 of file Simulator.hpp.

                                                                                                                                                       {
             Oracle<DerivedType>::bitStringNCU(static_cast<DerivedType&>(*this), bit_pattern, ctrlIndices, target, U, gateLabel);
         }

◆ applyOracleU() [2/2]

template<class DerivedType>

template<class Mat2x2Type >

void QNLP::SimulatorGeneral< DerivedType >::applyOracleU	(	std::size_t	bit_pattern,
		const std::vector< std::size_t > &	ctrlIndices,
		const std::vector< std::size_t > &	auxIndices,
		std::size_t	target,
		const Mat2x2Type &	U,
		std::string	gateLabel
	)

inline

Apply oracle to match given binary index with non adjacent controls.

Parameters

bit_pattern	Oracle state pattern (bitstring: 0-> \|0>, 1-> \|1>)
U	2x2 unitary matrix to apply
ctrlIndices	Control indices for operation
auxIndices	Auxiliary indices for operation
target	Target qubit index to apply U on
gateLabel	Label used to access required cached matrix for NCU

Definition at line 513 of file Simulator.hpp.

                                                                                                                                                                                               {
             Oracle<DerivedType>::bitStringNCU(static_cast<DerivedType&>(*this), bit_pattern, ctrlIndices, auxIndices, target, U, gateLabel);
         }

◆ applyQFT()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::applyQFT	(	std::size_t	minIdx,
		std::size_t	maxIdx
	)

inline

Apply the forward Quantum Fourier transform (QFT) to the given register index range.

Parameters

minIdx	Lowest qubit index of the QFT range
maxIdx	Highest qubit index of the QFT range

Definition at line 423 of file Simulator.hpp.

                                                          {
             QFT<decltype(static_cast<DerivedType&>(*this))>::applyQFT(static_cast<DerivedType&>(*this), minIdx, maxIdx);
         }

Referenced by QNLP::SimulatorGeneral< IntelSimulator >::applyQFT().

Here is the caller graph for this function:

◆ collapseToBasisZ()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::collapseToBasisZ	(	std::size_t	target,
		bool	collapseValue
	)

inline

Apply measurement to a target qubit with respect to the Z-basis, collapsing to a specified value (0 or 1). Amplitudes are r-normalized afterwards.

Parameters

target	The index of the qubit being collapsed
collapseValue	The value that the register will be collapsed to (either 0 ro 1).

Definition at line 671 of file Simulator.hpp.

                                                                    {
             static_cast<DerivedType*>(this)->collapseToBasisZ(target, collapseValue);
         }

◆ encodeBinToSuperpos_unique()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::encodeBinToSuperpos_unique	(	const std::vector< std::size_t > &	reg_memory,
		const std::vector< std::size_t > &	reg_auxiliary,
		const std::vector< std::size_t > &	bin_patterns,
		const std::size_t	len_bin_pattern
	)

inline

Encode inputted binary strings to the memory register specified as a superposition of states. Note that this implementation does not allow for multiple instances of the same input pattern but allows for 0 to be encoded.

Parameters

reg_memory	std::vector of unsigned integers containing the indices of the circuit's memory register
reg_auxiliary	std::vector of unsigned integers type containing the indices of the circuit's auxiliary register
bin_patterns	std::vector of unsigned integers representing the binary patterns to encode
len_bin_pattern	The length of the binary patterns being encoded

Definition at line 567 of file Simulator.hpp.

                                                 {
 
             EncodeBinIntoSuperpos<DerivedType> encoder(bin_patterns.size(), len_bin_pattern);
             encoder.encodeBinInToSuperpos_unique(static_cast<DerivedType&>(*this), reg_memory, reg_auxiliary, bin_patterns);
         }

◆ encodeToRegister()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::encodeToRegister	(	std::size_t	target_pattern,
		const std::vector< std::size_t >	target_register,
		std::size_t	len_bin_pattern
	)

inline

Encodes a defined binary pattern into a defined target register (initially in state |00...0>) of all quantum states in the superposition.

Parameters

target_pattern	The binary pattern that is to be encoded
target_register	Vector containing the indices of the register qubits that the pattern is to be encoded into (beginning at least significant digit). Note, the target register is expected to be in the state consisting of all 0's before the encoding.
Length	of the binary pattern to be encoded

Definition at line 548 of file Simulator.hpp.

                                           {
 
             for(std::size_t i = 0; i < len_bin_pattern; i++){
                 if(IS_SET(target_pattern,i)){
                     applyGateX(target_register[i]);
                 }
             }
         }

Referenced by QNLP::SimulatorGeneral< IntelSimulator >::applyHammingDistanceOverwrite(), and QNLP::SimulatorGeneral< IntelSimulator >::applyHammingDistanceRotY().

Here is the caller graph for this function:

◆ getGateH()

template<class DerivedType>

decltype(auto) QNLP::SimulatorGeneral< DerivedType >::getGateH ( )

inline

Get the Hadamard gate; must be overloaded with appropriate return type.

Returns: GateType Templated return type of Hadamard gate

Definition at line 238 of file Simulator.hpp.

                                  {
             return static_cast<DerivedType*>(this)->getGateH();
         }

◆ getGateI()

template<class DerivedType>

decltype(auto) QNLP::SimulatorGeneral< DerivedType >::getGateI ( )

inline

Get the Identity; must be overloaded with appropriate return type.

Returns: GateType Templated return type of Identity gate

Definition at line 231 of file Simulator.hpp.

                                  {
             return static_cast<DerivedType*>(this)->getGateI();
         }

◆ getGateX()

template<class DerivedType>

decltype(auto) QNLP::SimulatorGeneral< DerivedType >::getGateX ( )

inline

Get the Pauli-X gate; returns templated type GateType.

Returns: GateType Templated return type of Pauli-X gate

Definition at line 209 of file Simulator.hpp.

                                   {
             return static_cast<DerivedType&>(*this).getGateX();
         }

◆ getGateY()

template<class DerivedType>

decltype(auto) QNLP::SimulatorGeneral< DerivedType >::getGateY ( )

inline

Get the Pauli-Y gate; must be overloaded with appropriate return type.

Returns: GateType Templated return type of Pauli-Y gate

Definition at line 217 of file Simulator.hpp.

                                  {
             return static_cast<DerivedType&>(*this).getGateY();
         }

◆ getGateZ()

template<class DerivedType>

decltype(auto) QNLP::SimulatorGeneral< DerivedType >::getGateZ ( )

inline

Get the Pauli-Z gate; must be overloaded with appropriate return type.

Returns: GateType Templated return type of Pauli-Z gate

Definition at line 224 of file Simulator.hpp.

                                  {
             return static_cast<DerivedType&>(*this).getGateZ();
         }

◆ getNumQubits()

template<class DerivedType>

std::size_t QNLP::SimulatorGeneral< DerivedType >::getNumQubits ( )

inline

Get the number of Qubits.

Returns: std::size_t Number of qubits in register

Definition at line 413 of file Simulator.hpp.

                                 {
             return static_cast<DerivedType*>(this)->getNumQubits();    
         }

Referenced by QNLP::SimulatorGeneral< IntelSimulator >::applyGateCSwap(), and TEST_CASE().

Here is the caller graph for this function:

◆ getQubitRegister()

template<class DerivedType>

decltype(auto) QNLP::SimulatorGeneral< DerivedType >::getQubitRegister ( )

inline

Get the underlying qubit register object.

Returns: decltype(auto) the underlying bound qubit register

Definition at line 404 of file Simulator.hpp.

                                          { 
            return static_cast<DerivedType*>(this)->getQubitRegister();
         }

◆ groupQubits()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::groupQubits	(	const std::vector< std::size_t >	reg_auxiliary,
		bool	lsb = `true`
	)

inline

Group all set qubits to MSB in register (ie |010100> -> |000011>)

Parameters

reg_mem	The indices of the qubits to perform operation upon
reg_auxiliary	The auxiliary control qubit register set to \|......10> at the beginning, and guaranteed to be set the same at end.
lsb	Shifts to LSB position in register if true; MSB otherwise.

Definition at line 656 of file Simulator.hpp.

                                                                                  {
             assert( reg_auxiliary.size() >= 2);
 
             const std::vector<std::size_t> reg_ctrl ( reg_auxiliary.end()-2, reg_auxiliary.end() );
             const std::vector<std::size_t> sub_reg (reg_auxiliary.begin(), reg_auxiliary.end()-2 ) ;
 
             BitGroup<DerivedType>::bit_group(static_cast<DerivedType&>(*this), sub_reg, reg_ctrl, lsb);
         }

◆ initCaches()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::initCaches ( )

inline

Initialise caches used in NCU operation.

Definition at line 687 of file Simulator.hpp.

                          {
             #if defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER)
             std::experimental::any_cast<NCU<DerivedType>&>(sim_ncu).initialiseMaps(static_cast<DerivedType&>(*this), 16);
             #else
             std::any_cast<NCU<DerivedType>&>(sim_ncu).initialiseMaps(static_cast<DerivedType&>(*this), 16);
             #endif
         }

◆ initRegister()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::initRegister ( )

inline

(Re)Initialise the underlying register of the encapsulated simulator to well-defined state (|0....0>)

Definition at line 679 of file Simulator.hpp.

                            {
             static_cast<DerivedType&>(*this).initRegister();
         }

◆ InvertRegister()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::InvertRegister	(	const unsigned int	minIdx,
		const unsigned int	maxIdx
	)

inline

Invert the register about the given indides: 0,1,2...n-1,n -> n,n-1,...,1,0.

Parameters

minIdx	The lower index of the inversion
maxIdx	The upper index of the inversion

Definition at line 776 of file Simulator.hpp.

                                                                                  {
             unsigned int range2 = ((maxIdx - minIdx)%2 == 1) ? (maxIdx - minIdx)/2 +1 : (maxIdx - minIdx)/2;
             for(unsigned int idx = 0; idx < range2; idx++){
                 applyGateSwap(minIdx+idx, maxIdx-idx);
             }
         }

◆ matrixSqrt()

template<class DerivedType>

template<class Mat2x2Type >

Mat2x2Type QNLP::SimulatorGeneral< DerivedType >::matrixSqrt ( const Mat2x2Type & U )

inline

Calculates the unitary matrix square root (U == VV, where V is returned)

Template Parameters

Mat2x2Type Matrix type

Parameters

U	Unitary matrix to be rooted

Returns: openqu::TinyMatrix<Type, 2, 2, 32> V such that VV == U

Definition at line 729 of file Simulator.hpp.

                                                   {
             Mat2x2Type V(U);
             std::complex<double> delta = U(0,0)*U(1,1) - U(0,1)*U(1,0);
             std::complex<double> tau = U(0,0) + U(1,1);
             std::complex<double> s = sqrt(delta);
             std::complex<double> t = sqrt(tau + 2.0*s);
 
             //must be a way to vectorise these; TinyMatrix have a scale/shift option?
             V(0,0) += s;
             V(1,1) += s;
             std::complex<double> scale_factor(1.,0.);
             scale_factor/=t;
             V(0,0) *= scale_factor; //(std::complex<double>(1.,0.)/t);
             V(0,1) *= scale_factor; //(1/t);
             V(1,0) *= scale_factor; //(1/t);
             V(1,1) *= scale_factor; //(1/t);
 
             return V;
         }

◆ PrintStates()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::PrintStates	(	std::string	x,
		std::vector< std::size_t >	qubits = `{}`
	)

inline

Prints the string x and then for each state of the specified qubits in the superposition, prints each its amplitude, followed by state and then by the probability of that state. Note that this state observation method is not a permitted quantum operation, however it is provided for convenience and debugging/testing.

Parameters

x	String to be printed to stdout
qubits	Indices of qubits in register to be printed

Definition at line 717 of file Simulator.hpp.

                                                                     {}){
             static_cast<DerivedType*>(this)->PrintStates(x, qubits);
         }

◆ subReg()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::subReg	(	std::size_t	r0_minIdx,
		std::size_t	r0_maxIdx,
		std::size_t	r1_minIdx,
		std::size_t	r1_maxIdx
	)

inline

Applies |r1>|r2> -> |r1>|r1-r2>

Definition at line 448 of file Simulator.hpp.

                                                                                                        {
             Arithmetic<decltype(static_cast<DerivedType&>(*this))>::sub_reg(static_cast<DerivedType&>(*this), r0_minIdx, r0_maxIdx, r1_minIdx, r1_maxIdx);
         }

◆ sumReg()

template<class DerivedType>

void QNLP::SimulatorGeneral< DerivedType >::sumReg	(	std::size_t	r0_minIdx,
		std::size_t	r0_maxIdx,
		std::size_t	r1_minIdx,
		std::size_t	r1_maxIdx
	)

inline

Applies |r1>|r2> -> |r1>|r1+r2>

Definition at line 441 of file Simulator.hpp.

                                                                                                        {
             Arithmetic<decltype(static_cast<DerivedType&>(*this))>::sum_reg(static_cast<DerivedType&>(*this), r0_minIdx, r0_maxIdx, r1_minIdx, r1_maxIdx);
         }

Field Documentation

◆ DerivedType

template<class DerivedType>

friend QNLP::SimulatorGeneral< DerivedType >::DerivedType

private

Definition at line 91 of file Simulator.hpp.

◆ sim_ncu

template<class DerivedType>

std::any QNLP::SimulatorGeneral< DerivedType >::sim_ncu

protected

Definition at line 104 of file Simulator.hpp.

Referenced by QNLP::SimulatorGeneral< IntelSimulator >::addUToCache(), QNLP::SimulatorGeneral< IntelSimulator >::applyGateNCU(), QNLP::SimulatorGeneral< IntelSimulator >::initCaches(), and QNLP::SimulatorGeneral< IntelSimulator >::SimulatorGeneral().

The documentation for this class was generated from the following file:

/Users/mlxd/Desktop/intel-qnlp-rc2/modules/simulator/Simulator.hpp

Public Member Functions

Static Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

template<class DerivedType> class QNLP::SimulatorGeneral< DerivedType >

Constructor & Destructor Documentation

◆ SimulatorGeneral()

◆ ~SimulatorGeneral()

Member Function Documentation

◆ addUToCache()

◆ adjointMatrix()

◆ applyDiffusion()

◆ applyGateCCX()

◆ applyGateCH()

◆ applyGateCPhaseShift()

◆ applyGateCRotX()

◆ applyGateCRotY()

◆ applyGateCRotZ()

◆ applyGateCSwap()

◆ applyGateCU()

◆ applyGateCX()

◆ applyGateCY()

◆ applyGateCZ()

◆ applyGateH()

◆ applyGateI()

◆ applyGateNCU() [1/2]

◆ applyGateNCU() [2/2]

◆ applyGatePhaseShift()

◆ applyGateRotX()

◆ applyGateRotY()

◆ applyGateRotZ()

◆ applyGateSqrtSwap()

◆ applyGateSqrtX()

◆ applyGateSwap()

◆ applyGateU()

◆ applyGateX()

◆ applyGateY()

◆ applyGateZ()

◆ applyHammingDistanceOverwrite()

◆ applyHammingDistanceRotY()

◆ applyIQFT()

◆ applyMeasurement()

◆ applyMeasurementToRegister()

◆ applyOraclePhase()

◆ applyOracleU() [1/2]

◆ applyOracleU() [2/2]

◆ applyQFT()

◆ collapseToBasisZ()

◆ encodeBinToSuperpos_unique()

◆ encodeToRegister()

◆ getGateH()

◆ getGateI()

◆ getGateX()

◆ getGateY()

◆ getGateZ()

◆ getNumQubits()

◆ getQubitRegister()

◆ groupQubits()

◆ initCaches()

◆ initRegister()

◆ InvertRegister()

◆ matrixSqrt()

◆ PrintStates()

◆ subReg()

◆ sumReg()

Field Documentation

◆ DerivedType

◆ sim_ncu

template<class DerivedType>
class QNLP::SimulatorGeneral< DerivedType >