Functions used in the unit testing. These are mostly unoptimised, analytic implementations of the complex linear algebra that QuEST ultimately effects on quantum states. These are not part of the QuEST API, and require C++14. More...

Typedefs
typedef std::vector< std::vector< qcomp > >	QMatrix
	A complex square matrix. More...

typedef std::vector< qcomp >	QVector
	A complex vector, which can be zero-initialised with QVector(numAmps). More...

Functions
void	applyReferenceOp (QMatrix &state, int ctrls, int numCtrls, int targs, int numTargs, QMatrix op)
	Modifies the density matrix `state` to be the result of applying the multi-target operator matrix `op`, with the specified control and target qubits (in `ctrls` and `targs` respectively). More...

void	applyReferenceOp (QMatrix &state, int *ctrls, int numCtrls, int targ1, int targ2, QMatrix op)
	Modifies the density matrix `state` to be the result of applying the two-target operator matrix `op`, with the specified control qubits (in `ctrls`). More...

void	applyReferenceOp (QMatrix &state, int *ctrls, int numCtrls, int target, QMatrix op)
	Modifies the density matrix `state` to be the result of applying the single-target operator matrix `op`, with the specified control qubits (in `ctrls`). More...

void	applyReferenceOp (QMatrix &state, int *targs, int numTargs, QMatrix op)
	Modifies the density matrix `state` to be the result of applying the multi-target operator matrix `op`, with no control qubits. More...

void	applyReferenceOp (QMatrix &state, int ctrl, int *targs, int numTargs, QMatrix op)
	Modifies the density matrix `state` to be the result of applying the multi-target operator matrix `op`, with a single control qubit `ctrl`. More...

void	applyReferenceOp (QMatrix &state, int ctrl, int targ, QMatrix op)
	Modifies the density matrix `state` to be the result of applying the single-control single-target operator matrix `op`. More...

void	applyReferenceOp (QMatrix &state, int ctrl, int targ1, int targ2, QMatrix op)
	Modifies the density matrix `state` to be the result of applying the two-target operator matrix `op`, with a single control qubit `ctrl`. More...

void	applyReferenceOp (QMatrix &state, int targ, QMatrix op)
	Modifies the density matrix `state` to be the result of applying the single-target operator matrix `op`, with no control qubit. More...

void	applyReferenceOp (QVector &state, int ctrls, int numCtrls, int targs, int numTargs, QMatrix op)
	Modifies the state-vector `state` to be the result of applying the multi-target operator matrix `op`, with the specified control and target qubits (in `ctrls` and `targs` respectively). More...

void	applyReferenceOp (QVector &state, int *ctrls, int numCtrls, int targ1, int targ2, QMatrix op)
	Modifies the state-vector `state` to be the result of applying the two-target operator matrix `op`, with the specified control qubits (in `ctrls`). More...

void	applyReferenceOp (QVector &state, int *ctrls, int numCtrls, int target, QMatrix op)
	Modifies the state-vector `state` to be the result of applying the single-target operator matrix `op`, with the specified control qubits (in `ctrls`). More...

void	applyReferenceOp (QVector &state, int *targs, int numTargs, QMatrix op)
	Modifies the state-vector `state` to be the result of applying the multi-target operator matrix `op`, with no contorl qubits. More...

void	applyReferenceOp (QVector &state, int ctrl, int *targs, int numTargs, QMatrix op)
	Modifies the state-vector `state` to be the result of applying the multi-target operator matrix `op`, with a single control qubit (`ctrl`) This updates `state` under. More...

void	applyReferenceOp (QVector &state, int ctrl, int targ, QMatrix op)
	Modifies the state-vector `state` to be the result of applying the single-target operator matrix `op`, with a single control qubit (`ctrl`). More...

void	applyReferenceOp (QVector &state, int ctrl, int targ1, int targ2, QMatrix op)
	Modifies the state-vector `state` to be the result of applying the two-target operator matrix `op`, with a single control qubit (`ctrl`). More...

void	applyReferenceOp (QVector &state, int targ, QMatrix op)
	Modifies the state-vector `state` to be the result of applying the single-target operator matrix `op`, with no contorl qubits. More...

bool	areEqual (QMatrix a, QMatrix b)
	Returns true if the absolute value of the difference between every amplitude in matrices `a` and `b` is less than `REAL_EPS`. More...

bool	areEqual (Qureg qureg, QMatrix matr)
	Performs a hardware-agnostic comparison of density-matrix `qureg` to `matr`, checking whether the difference between the real and imaginary components of every amplitude is smaller than the QuEST_PREC-specific REAL_EPS (defined in QuEST_precision) precision. More...

bool	areEqual (Qureg qureg, QMatrix matr, qreal precision)
	Performs a hardware-agnostic comparison of density-matrix `qureg` to `matr`, checking whether the difference between the real and imaginary components of every amplitude is smaller than `precision`. More...

bool	areEqual (Qureg qureg, QVector vec)
	Performs a hardware-agnostic comparison of state-vector `qureg` to `vec`, checking whether the difference between the real and imaginary components of every amplitude is smaller than the QuEST_PREC-specific REAL_EPS (defined in QuEST_precision) precision. More...

bool	areEqual (Qureg qureg, QVector vec, qreal precision)
	Performs a hardware-agnostic comparison of state-vector `qureg` to `vec`, checking whether the difference between the real and imaginary components of every amplitude is smaller than `precision`. More...

bool	areEqual (Qureg qureg1, Qureg qureg2)
	Performs a hardware-agnostic comparison of the given quregs, checking whether the difference between the real and imaginary components of every amplitude is smaller than the QuEST_PREC-specific REAL_EPS (defined in QuEST_precision) precision. More...

bool	areEqual (Qureg qureg1, Qureg qureg2, qreal precision)
	Performs a hardware-agnostic comparison of the given quregs, checking whether the difference between the real and imaginary components of every amplitude is smaller than `precision`. More...

bool	areEqual (QVector a, QVector b)
	Returns true if the absolute value of the difference between every amplitude in vectors `a` and `b` is less than `REAL_EPS`. More...

CatchGen< int * >	bitsets (int numBits)
	Returns a Catch2 generator of every `numBits-length` bit-set, in increasing lexographic order, where left-most (zero index) bit is treated as LEAST significant (opposite typical convention). More...

unsigned int	calcLog2 (long unsigned int res)
	Returns log2 of numbers which must be gauranteed to be 2^n. More...

QMatrix	getConjugateTranspose (QMatrix a)
	Returns the conjugate transpose of the complex square matrix `a`. More...

QMatrix	getExponentialOfDiagonalMatrix (QMatrix a)
	Returns the matrix exponential of a diagonal, square, complex matrix. More...

QMatrix	getExponentialOfPauliMatrix (qreal angle, QMatrix a)
	Returns the matrix exponential of a kronecker product of pauli matrices (or of any involutory matrices), with exponent factor (-i `angle` / 2). More...

QMatrix	getFullOperatorMatrix (int ctrls, int numCtrls, int targs, int numTargs, QMatrix op, int numQubits)
	Takes a 2^`numTargs-by-2^numTargs matrix` `op` and a returns a 2^`numQubits-by-2^numQubits matrix` where `op` is controlled on the given `ctrls` qubits. More...

QMatrix	getIdentityMatrix (size_t dim)
	Returns a dim-by-dim identity matrix. More...

QMatrix	getKetBra (QVector ket, QVector bra)
	Returns the matrix \|`ket><bra\|,` with ith-jth element `ket(i)` conj(`bra(j)`), since \|`ket><bra\| =` sum_i a_i\|i> sum_j b_j* <j\| = sum_{ij} a_i b_j* \|i><j\|. More...

QMatrix	getKroneckerProduct (QMatrix a, QMatrix b)
	Returns the kronecker product of `a` and `b`, where `a` and `b` are square but possibly differently-sized complex matrices. More...

QVector	getNormalised (QVector vec)
	Returns an L2-normalised copy of `vec`, using Kahan summation for improved accuracy. More...

QMatrix	getRandomDensityMatrix (int numQb)
	Returns a random `numQb-by-numQb density` matrix, from an undisclosed distribution, in a very mixed state. More...

int	getRandomInt (int min, int max)
	Returns a random integer between `min` (inclusive) and `max` (exclusive), from the uniform distribution. More...

std::vector< QMatrix >	getRandomKrausMap (int numQb, int numOps)
	Returns a random Kraus map of `#numOps` 2^`numQb-by-2^numQb operators`, from an undisclosed distribution. More...

QMatrix	getRandomQMatrix (int dim)
	Returns a `dim-by-dim complex` matrix, where the real and imaginary value of each element are independently random, under the standard normal distribution (mean 0, standard deviation 1). More...

QVector	getRandomQVector (int dim)
	Returns a `dim-length` vector with random complex amplitudes in the square joining {-1-i, 1+i}, of an undisclosed distribution. More...

qreal	getRandomReal (qreal min, qreal max)
	Returns a random real between `min` (inclusive) and `max` (exclusive), from the uniform distribution. More...

QVector	getRandomStateVector (int numQb)
	Returns a random `numQb-length` L2-normalised state-vector from an undisclosed distribution. More...

QMatrix	getRandomUnitary (int numQb)
	Returns a uniformly random (under Haar) 2^`numQb-by-2^numQb unitary` matrix. More...

QMatrix	getSwapMatrix (int qb1, int qb2, int numQb)
	Returns the 2^`numQb-by-2^numQb unitary` matrix which swaps qubits `qb1` and `qb2`; the SWAP gate of not-necessarily-adjacent qubits. More...

QMatrix	getZeroMatrix (size_t dim)
	Returns a dim-by-dim square complex matrix, initialised to all zeroes. More...

CatchGen< pauliOpType * >	pauliseqs (int numPaulis)
	Returns a Catch2 generator of every `numPaulis-length` set of Pauli-matrix types (or base-4 integers). More...

CatchGen< int * >	sequences (int base, int numDigits)
	Returns a Catch2 generator of every `numDigits-length` sequence in the given `base`, in increasing lexographic order, where left-most (zero index) bit is treated as LEAST significant (opposite typical convention). More...

void	setSubMatrix (QMatrix &dest, QMatrix sub, size_t r, size_t c)
	Modifies `dest` by overwriting its submatrix (from top-left corner (`r`, `c`) to bottom-right corner (`r` + `dest.size()`, `c` + `dest.size()`) with the complete elements of sub. More...

CatchGen< int * >	sublists (CatchGen< int > &&gen, int numSamps, const int *exclude, int numExclude)
	Returns a Catch2 generator of every length-`sublen` sublist of the elements generated by `gen`, which exclude all elements in `exclude`, in increasing lexographic order. More...

CatchGen< int * >	sublists (CatchGen< int > &&gen, int numSamps, int excluded)
	Returns a Catch2 generator of every length-`sublen` sublist of the elements generated by `gen` which exclude element `excluded`, in increasing lexographic order. More...

CatchGen< int * >	sublists (CatchGen< int > &&gen, int sublen)
	Returns a Catch2 generator of every length-`sublen` sublist of the elements generated by `gen`, in increasing lexographic order. More...

CatchGen< int * >	sublists (int *list, int len, int sublen)
	Returns a Catch2 generator of every length-`sublen` sublist of length-`len` `list`, in increasing lexographic order. More...

ComplexMatrix2	toComplexMatrix2 (QMatrix qm)
	Returns a `ComplexMatrix2` copy of QMatix `qm`. More...

ComplexMatrix4	toComplexMatrix4 (QMatrix qm)
	Returns a `ComplexMatrix4` copy of QMatix `qm`. More...

void	toComplexMatrixN (QMatrix qm, ComplexMatrixN cm)
	Initialises `cm` with the values of `qm`. More...

QMatrix	toQMatrix (Complex alpha, Complex beta)
	Returns the matrix (where a=`alpha`, b=`beta`) {{a, -conj(b)}, {b, conj(a)}} using the `qcomp` complex type. More...

QMatrix	toQMatrix (ComplexMatrix2 src)
	Returns a copy of the given 2-by-2 matrix. More...

QMatrix	toQMatrix (ComplexMatrix4 src)
	Returns a copy of the given 4-by-4 matrix. More...

QMatrix	toQMatrix (ComplexMatrixN src)
	Returns a copy of the given 2^`N-by-2^n matrix`. More...

QMatrix	toQMatrix (Qureg qureg)
	Returns an equal-size copy of the given density matrix `qureg`. More...

void	toQureg (Qureg qureg, QMatrix mat)
	Initialises the density matrix `qureg` to have the same amplitudes as `mat`. More...

void	toQureg (Qureg qureg, QVector vec)
	Initialises the state-vector `qureg` to have the same amplitudes as `vec`. More...

QVector	toQVector (Qureg qureg)
	Returns an equal-size copy of the given state-vector `qureg`. More...

Detailed Description

Functions used in the unit testing. These are mostly unoptimised, analytic implementations of the complex linear algebra that QuEST ultimately effects on quantum states. These are not part of the QuEST API, and require C++14.

Author: Tyson Jones

Typedef Documentation

◆ QMatrix

typedef std::vector<std::vector<qcomp> > QMatrix

A complex square matrix.

Should be initialised with getZeroMatrix(). These have all the natural linear-algebra operator overloads, including left-multiplication onto a vector.

This data-structure is not partitioned between nodes in distributed mode. That is, every node has a complete copy, allowing for safe comparisons.

Author: Tyson Jones

Definition at line 49 of file utilities.hpp.

◆ QVector

typedef std::vector<qcomp> QVector

A complex vector, which can be zero-initialised with QVector(numAmps).

These have all the natural linear-algebra operator overloads.

This data-structure is not partitioned between nodes in distributed mode. That is, every node has a complete copy, allowing for safe comparisons.

Author: Tyson Jones

Definition at line 60 of file utilities.hpp.

Function Documentation

◆ applyReferenceOp() [1/16]

void applyReferenceOp	(	QMatrix &	state,
		int *	ctrls,
		int	numCtrls,
		int *	targs,
		int	numTargs,
		QMatrix	op
	)

Modifies the density matrix state to be the result of applying the multi-target operator matrix op, with the specified control and target qubits (in ctrls and targs respectively).

This updates state under

$\text{state} \to \text{op} \, \text{state} \, \text{op}^\dagger$

even if op is not unitary (which is useful for applying Kraus operators).

op must be a 2^numTargs-by-2^numTargs matrix. Furthermore, every element of targs must not appear in ctrls (and vice-versa), though this is not explicitly checked. Elements of targs and ctrls should be unique.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multipling it to state, then right-multiplying its conjugate transpose onto the result.

Author: Tyson Jones

Definition at line 629 of file utilities.cpp.

   {
     int numQubits = calcLog2(state.size());
     QMatrix leftOp = getFullOperatorMatrix(ctrls, numCtrls, targs, numTargs, op, numQubits);
     QMatrix rightOp = getConjugateTranspose(leftOp);
     state = leftOp * state * rightOp;
 }

References calcLog2(), getConjugateTranspose(), and getFullOperatorMatrix().

◆ applyReferenceOp() [2/16]

void applyReferenceOp	(	QMatrix &	state,
		int *	ctrls,
		int	numCtrls,
		int	targ1,
		int	targ2,
		QMatrix	op
	)

Modifies the density matrix state to be the result of applying the two-target operator matrix op, with the specified control qubits (in ctrls).

This updates state under

$\text{state} \to \text{op} \, \text{state} \, \text{op}^\dagger$

even if op is not unitary (which is useful for applying Kraus operators).

op must be a 4-by-4 matrix. Both targ1 and targ2 must not appear in ctrls, though this is not explicitly checked. Elements of ctrls, and targ1 and targ2, should be unique.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multipling it to state, then right-multiplying its conjugate transpose onto the result.

Author: Tyson Jones

Definition at line 580 of file utilities.cpp.

   {
     int targs[2] = {targ1, targ2};
     applyReferenceOp(state, ctrls, numCtrls, targs, 2, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [3/16]

void applyReferenceOp	(	QMatrix &	state,
		int *	ctrls,
		int	numCtrls,
		int	target,
		QMatrix	op
	)

Modifies the density matrix state to be the result of applying the single-target operator matrix op, with the specified control qubits (in ctrls).

This updates state under

$\text{state} \to \text{op} \, \text{state} \, \text{op}^\dagger$

even if op is not unitary (which is useful for applying Kraus operators).

op must be a 2-by-2 matrix. target must not appear in ctrls, though this is not explicitly checked.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multipling it to state, then right-multiplying its conjugate transpose onto the result.

Author: Tyson Jones

Definition at line 643 of file utilities.cpp.

   {
     int targs[1] = {target};
     applyReferenceOp(state, ctrls, numCtrls, targs, 1, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [4/16]

void applyReferenceOp	(	QMatrix &	state,
		int *	targs,
		int	numTargs,
		QMatrix	op
	)

Modifies the density matrix state to be the result of applying the multi-target operator matrix op, with no control qubits.

This updates state under

$\text{state} \to \text{op} \, \text{state} \, \text{op}^\dagger$

even if op is not unitary (which is useful for applying Kraus operators).

op must be a 2^numTargs-by-2^numTargs matrix. Every element in targs should be unique, though this is not explicitly checked.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multipling it to state, then right-multiplying its conjugate transpose onto the result.

Author: Tyson Jones

Definition at line 649 of file utilities.cpp.

   {
     applyReferenceOp(state, NULL, 0, targs, numTargs, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [5/16]

void applyReferenceOp	(	QMatrix &	state,
		int	ctrl,
		int *	targs,
		int	numTargs,
		QMatrix	op
	)

Modifies the density matrix state to be the result of applying the multi-target operator matrix op, with a single control qubit ctrl.

This updates state under

$\text{state} \to \text{op} \, \text{state} \, \text{op}^\dagger$

even if op is not unitary (which is useful for applying Kraus operators).

op must be a 2^numTargs-by-2^numTargs matrix, and ctrl must not appear in targs (though this is not explicitly checked).

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multipling it to state, then right-multiplying its conjugate transpose onto the result.

Author: Tyson Jones

Definition at line 661 of file utilities.cpp.

   {
     int ctrls[1] = {ctrl};
     applyReferenceOp(state, ctrls, 1, targs, numTargs, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [6/16]

void applyReferenceOp	(	QMatrix &	state,
		int	ctrl,
		int	targ,
		QMatrix	op
	)

Modifies the density matrix state to be the result of applying the single-control single-target operator matrix op.

This updates state under

$\text{state} \to \text{op} \, \text{state} \, \text{op}^\dagger$

even if op is not unitary (which is useful for applying Kraus operators).

op must be a 2-by-2 matrix, and ctrl and targ should be different.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multipling it to state, then right-multiplying its conjugate transpose onto the result.

Author: Tyson Jones

Definition at line 654 of file utilities.cpp.

   {
     int ctrls[1] = {ctrl};
     int targs[1] = {targ};
     applyReferenceOp(state, ctrls, 1, targs, 1, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [7/16]

void applyReferenceOp	(	QMatrix &	state,
		int	ctrl,
		int	targ1,
		int	targ2,
		QMatrix	op
	)

Modifies the density matrix state to be the result of applying the two-target operator matrix op, with a single control qubit ctrl.

This updates state under

$\text{state} \to \text{op} \, \text{state} \, \text{op}^\dagger$

even if op is not unitary (which is useful for applying Kraus operators).

op must be a 4-by-4 matrix, and ctrl, targ1 and targ2 must be unique.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multipling it to state, then right-multiplying its conjugate transpose onto the result.

Author: Tyson Jones

Definition at line 667 of file utilities.cpp.

   {
     int ctrls[1] = {ctrl};
     int targs[2] = {targ1, targ2};
     applyReferenceOp(state, ctrls, 1, targs, 2, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [8/16]

void applyReferenceOp	(	QMatrix &	state,
		int	targ,
		QMatrix	op
	)

Modifies the density matrix state to be the result of applying the single-target operator matrix op, with no control qubit.

This updates state under

$\text{state} \to \text{op} \, \text{state} \, \text{op}^\dagger$

even if op is not unitary (which is useful for applying Kraus operators).

op must be a 2-by-2 matrix.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multipling it to state, then right-multiplying its conjugate transpose onto the result.

Author: Tyson Jones

Definition at line 674 of file utilities.cpp.

   {
     int targs[1] = {targ};
     applyReferenceOp(state, NULL, 0, targs, 1, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [9/16]

void applyReferenceOp	(	QVector &	state,
		int *	ctrls,
		int	numCtrls,
		int *	targs,
		int	numTargs,
		QMatrix	op
	)

Modifies the state-vector state to be the result of applying the multi-target operator matrix op, with the specified control and target qubits (in ctrls and targs respectively).

This updates state under

$\text{state} \to \text{op} \, \text{state}$

even if op is not unitary.

op must be a 2^numTargs-by-2^numTargs matrix. Furthermore, every element of targs must not appear in ctrls (and vice-versa), though this is not explicitly checked. Elements of targs and ctrls should be unique.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multiplying it onto state.

Author: Tyson Jones

Definition at line 573 of file utilities.cpp.

   {
     int numQubits = calcLog2(state.size());
     QMatrix fullOp = getFullOperatorMatrix(ctrls, numCtrls, targs, numTargs, op, numQubits);
     state = fullOp * state;
 }

References calcLog2(), and getFullOperatorMatrix().

Referenced by applyReferenceOp(), and TEST_CASE().

◆ applyReferenceOp() [10/16]

void applyReferenceOp	(	QVector &	state,
		int *	ctrls,
		int	numCtrls,
		int	targ1,
		int	targ2,
		QMatrix	op
	)

Modifies the state-vector state to be the result of applying the two-target operator matrix op, with the specified control qubits (in ctrls).

This updates state under

$\text{state} \to \text{op} \, \text{state}$

even if op is not unitary.

op must be a 4-by-4 matrix. Furthermore, ctrls, targ1 and targ2 should all be unique.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multiplying it onto state.

Author: Tyson Jones

Definition at line 637 of file utilities.cpp.

   {
     int targs[2] = {targ1, targ2};
     applyReferenceOp(state, ctrls, numCtrls, targs, 2, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [11/16]

void applyReferenceOp	(	QVector &	state,
		int *	ctrls,
		int	numCtrls,
		int	target,
		QMatrix	op
	)

Modifies the state-vector state to be the result of applying the single-target operator matrix op, with the specified control qubits (in ctrls).

This updates state under

$\text{state} \to \text{op} \, \text{state}$

even if op is not unitary.

op must be a 2-by-2 matrix. Furthermore, elements in ctrls and target should all be unique.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multiplying it onto state.

Author: Tyson Jones

Definition at line 586 of file utilities.cpp.

   {
     int targs[1] = {target};
     applyReferenceOp(state, ctrls, numCtrls, targs, 1, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [12/16]

void applyReferenceOp	(	QVector &	state,
		int *	targs,
		int	numTargs,
		QMatrix	op
	)

Modifies the state-vector state to be the result of applying the multi-target operator matrix op, with no contorl qubits.

This updates state under

$\text{state} \to \text{op} \, \text{state}$

even if op is not unitary.

op must be a 2^numTargs-by-2^numTargs matrix. Furthermore, elements in targs should be unique.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multiplying it onto state.

Author: Tyson Jones

Definition at line 592 of file utilities.cpp.

   {
     applyReferenceOp(state, NULL, 0, targs, numTargs, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [13/16]

void applyReferenceOp	(	QVector &	state,
		int	ctrl,
		int *	targs,
		int	numTargs,
		QMatrix	op
	)

Modifies the state-vector state to be the result of applying the multi-target operator matrix op, with a single control qubit (ctrl) This updates state under.

$\text{state} \to \text{op} \, \text{state}$

even if op is not unitary.

op must be a 2^numTargs-by-2^numTargs matrix. Furthermore, elements in targs and ctrl should be unique.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multiplying it onto state.

Author: Tyson Jones

Definition at line 604 of file utilities.cpp.

   {
     int ctrls[1] = {ctrl};
     applyReferenceOp(state, ctrls, 1, targs, numTargs, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [14/16]

void applyReferenceOp	(	QVector &	state,
		int	ctrl,
		int	targ,
		QMatrix	op
	)

Modifies the state-vector state to be the result of applying the single-target operator matrix op, with a single control qubit (ctrl).

This updates state under

$\text{state} \to \text{op} \, \text{state}$

even if op is not unitary.

op must be a 2-by-2 matrix. Furthermore, ctrl and targ must be different.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multiplying it onto state.

Author: Tyson Jones

Definition at line 597 of file utilities.cpp.

   {
     int ctrls[1] = {ctrl};
     int targs[1] = {targ};
     applyReferenceOp(state, ctrls, 1, targs, 1, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [15/16]

void applyReferenceOp	(	QVector &	state,
		int	ctrl,
		int	targ1,
		int	targ2,
		QMatrix	op
	)

Modifies the state-vector state to be the result of applying the two-target operator matrix op, with a single control qubit (ctrl).

This updates state under

$\text{state} \to \text{op} \, \text{state}$

even if op is not unitary.

op must be a 4-by-4 matrix. Furthermore, ctrl, targ1 and targ2 should all be unique.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multiplying it onto state.

Author: Tyson Jones

Definition at line 610 of file utilities.cpp.

   {
     int ctrls[1] = {ctrl};
     int targs[2] = {targ1, targ2};
     applyReferenceOp(state, ctrls, 1, targs, 2, op);
 }

References applyReferenceOp().

◆ applyReferenceOp() [16/16]

void applyReferenceOp	(	QVector &	state,
		int	targ,
		QMatrix	op
	)

Modifies the state-vector state to be the result of applying the single-target operator matrix op, with no contorl qubits.

This updates state under

$\text{state} \to \text{op} \, \text{state}$

even if op is not unitary.

op must be a 2-by-2 matrix.

This function works by computing getFullOperatorMatrix() from the given arguments, and left-multiplying it onto state.

Author: Tyson Jones

Definition at line 617 of file utilities.cpp.

   {
     int targs[1] = {targ};
     applyReferenceOp(state, NULL, 0, targs, 1, op);
 }

References applyReferenceOp().

◆ areEqual() [1/8]

bool areEqual	(	QMatrix	a,
		QMatrix	b
	)

Returns true if the absolute value of the difference between every amplitude in matrices a and b is less than REAL_EPS.

Author: Tyson Jones

Definition at line 396 of file utilities.cpp.

                                     {
     DEMAND( a.size() == b.size() );
     
     for (size_t i=0; i<a.size(); i++)
         for (size_t j=0; j<b.size(); j++)
             if (abs(a[i][j] - b[i][j]) > REAL_EPS)
                 return false;
     return true;
 }

References DEMAND.

◆ areEqual() [2/8]

bool areEqual	(	Qureg	qureg,
		QMatrix	matr
	)

Performs a hardware-agnostic comparison of density-matrix qureg to matr, checking whether the difference between the real and imaginary components of every amplitude is smaller than the QuEST_PREC-specific REAL_EPS (defined in QuEST_precision) precision.

This function demands qureg is a density matrix, and that qureg and matr have equal dimensions.

In GPU mode, this function involves a GPU to CPU memory copy overhead. In distributed mode, it involves a all-to-all single-int broadcast.

Author: Tyson Jones

Definition at line 799 of file utilities.cpp.

                                          {
     return areEqual(qureg, matr, REAL_EPS);
 }

References areEqual().

◆ areEqual() [3/8]

bool areEqual	(	Qureg	qureg,
		QMatrix	matr,
		qreal	precision
	)

Performs a hardware-agnostic comparison of density-matrix qureg to matr, checking whether the difference between the real and imaginary components of every amplitude is smaller than precision.

This function demands qureg is a density matrix, and that qureg and matr have equal dimensions.

In GPU mode, this function involves a GPU to CPU memory copy overhead. In distributed mode, it involves a all-to-all single-int broadcast.

Author: Tyson Jones

Definition at line 747 of file utilities.cpp.

                                                           {
     DEMAND( qureg.isDensityMatrix );
     DEMAND( (int) (matr.size()*matr.size()) == qureg.numAmpsTotal );
     
     // ensure local qureg.stateVec is up to date
     copyStateFromGPU(qureg);
     syncQuESTEnv(QUEST_ENV);
     
     // the starting index in vec of this node's qureg partition.
     long long int startInd = qureg.chunkId * qureg.numAmpsPerChunk;
     long long int globalInd, row, col, i;
     int ampsAgree;
     
     // compare each of this node's amplitude to the corresponding matr sub-matrix
     for (i=0; i<qureg.numAmpsPerChunk; i++) {
         globalInd = startInd + i;
         row = globalInd % matr.size();
         col = globalInd / matr.size();
         qreal realDif = absReal(qureg.stateVec.real[i] - real(matr[row][col]));
         qreal imagDif = absReal(qureg.stateVec.imag[i] - imag(matr[row][col]));
         ampsAgree = (realDif < precision && imagDif < precision);
         
         // DEBUG
         if (!ampsAgree) {
             printf("node %d has a disagreement at (global) index %lldd of (%g) + i(%g)\n", 
                 qureg.chunkId, globalInd, realDif, imagDif
             );
         }
  
         // break loop as soon as amplitudes disagree
         if (!ampsAgree)
             break;
             
         /* TODO:
          * of the nodes which disagree, the lowest-rank should send its 
          * disagreeing (i, row, col, stateVec[i]) to rank 0 which should 
          * report it immediately (before the impending DEMAND failure)
          * using FAIL_CHECK, so users can determine nature of disagreement 
          * (e.g. numerical precision).
          * Note FAIL_CHECK accepts << like cout, e.g.
          * FAIL_CHECK( "Amp at (" << row << ", " << col ") disagreed" );
          */
     }
     
     // if one node's partition wasn't equal, all-nodes must report not-equal
     int allAmpsAgree = ampsAgree;
 #ifdef DISTRIBUTED_MODE
     MPI_Allreduce(&ampsAgree, &allAmpsAgree, 1, MPI_INT, MPI_LAND, MPI_COMM_WORLD);
 #endif
         
     return allAmpsAgree;
 }

References Qureg::chunkId, copyStateFromGPU(), DEMAND, Qureg::isDensityMatrix, Qureg::numAmpsPerChunk, Qureg::numAmpsTotal, qreal, QUEST_ENV, Qureg::stateVec, and syncQuESTEnv().

◆ areEqual() [4/8]

bool areEqual	(	Qureg	qureg,
		QVector	vec
	)

Performs a hardware-agnostic comparison of state-vector qureg to vec, checking whether the difference between the real and imaginary components of every amplitude is smaller than the QuEST_PREC-specific REAL_EPS (defined in QuEST_precision) precision.

This function demands qureg is a state-vector, and that qureg and vec have the same number of amplitudes.

In GPU mode, this function involves a GPU to CPU memory copy overhead. In distributed mode, it involves a all-to-all single-int broadcast.

Author: Tyson Jones

Definition at line 743 of file utilities.cpp.

                                         {
     return areEqual(qureg, vec, REAL_EPS);
 }

References areEqual().

◆ areEqual() [5/8]

bool areEqual	(	Qureg	qureg,
		QVector	vec,
		qreal	precision
	)

Performs a hardware-agnostic comparison of state-vector qureg to vec, checking whether the difference between the real and imaginary components of every amplitude is smaller than precision.

This function demands qureg is a state-vector, and that qureg and vec have the same number of amplitudes.

In GPU mode, this function involves a GPU to CPU memory copy overhead. In distributed mode, it involves a all-to-all single-int broadcast.

Author: Tyson Jones

Definition at line 708 of file utilities.cpp.

                                                          {
     DEMAND( !qureg.isDensityMatrix );
     DEMAND( (int) vec.size() == qureg.numAmpsTotal );
     
     copyStateFromGPU(qureg);
     syncQuESTEnv(QUEST_ENV);
     
     // the starting index in vec of this node's qureg partition.
     long long int startInd = qureg.chunkId * qureg.numAmpsPerChunk;
             
     int ampsAgree = 1;
     for (long long int i=0; i<qureg.numAmpsPerChunk; i++) {
         qreal realDif = absReal(qureg.stateVec.real[i] - real(vec[startInd+i]));
         qreal imagDif = absReal(qureg.stateVec.imag[i] - imag(vec[startInd+i]));
  
         if (realDif > precision || imagDif > precision) {
             ampsAgree = 0;
             
             // debug
             printf("Disagreement at %lld: %g + i(%g) VS %g + i(%g)\n",
                 startInd+i, qureg.stateVec.real[i], qureg.stateVec.imag[i],
                 real(vec[startInd+i]), imag(vec[startInd+i]));
             
             break;
         }
     }
             
     // if one node's partition wasn't equal, all-nodes must report not-equal
     int allAmpsAgree = ampsAgree;
 #ifdef DISTRIBUTED_MODE
     MPI_Allreduce(&ampsAgree, &allAmpsAgree, 1, MPI_INT, MPI_LAND, MPI_COMM_WORLD);
 #endif
     
     return allAmpsAgree;
 }

References Qureg::chunkId, copyStateFromGPU(), DEMAND, Qureg::isDensityMatrix, Qureg::numAmpsPerChunk, Qureg::numAmpsTotal, qreal, QUEST_ENV, Qureg::stateVec, and syncQuESTEnv().

◆ areEqual() [6/8]

bool areEqual	(	Qureg	qureg1,
		Qureg	qureg2
	)

Performs a hardware-agnostic comparison of the given quregs, checking whether the difference between the real and imaginary components of every amplitude is smaller than the QuEST_PREC-specific REAL_EPS (defined in QuEST_precision) precision.

This function demands that qureg1 and qureg2 are of the same type (i.e. both state-vectors or both density matrices), and of an equal number of qubits.

In GPU mode, this function involves a GPU to CPU memory copy overhead. In distributed mode, it involves a all-to-all single-int broadcast.

Author: Tyson Jones

Definition at line 704 of file utilities.cpp.

                                           {
     return areEqual(qureg1, qureg2, REAL_EPS);
 }

References areEqual().

◆ areEqual() [7/8]

bool areEqual	(	Qureg	qureg1,
		Qureg	qureg2,
		qreal	precision
	)

Performs a hardware-agnostic comparison of the given quregs, checking whether the difference between the real and imaginary components of every amplitude is smaller than precision.

This function demands that qureg1 and qureg2 are of the same type (i.e. both state-vectors or both density matrices), and of an equal number of qubits.

In GPU mode, this function involves a GPU to CPU memory copy overhead. In distributed mode, it involves a all-to-all single-int broadcast.

Author: Tyson Jones

Definition at line 681 of file utilities.cpp.

                                                            {
     DEMAND( qureg1.isDensityMatrix == qureg2.isDensityMatrix );
     DEMAND( qureg1.numAmpsTotal == qureg2.numAmpsTotal );
         
     copyStateFromGPU(qureg1);
     copyStateFromGPU(qureg2);
     syncQuESTEnv(QUEST_ENV);
     
     // loop terminates when areEqual = 0
     int ampsAgree = 1;
     for (long long int i=0; ampsAgree && i<qureg1.numAmpsPerChunk; i++)
         ampsAgree = (
                absReal(qureg1.stateVec.real[i] - qureg2.stateVec.real[i]) < precision
             && absReal(qureg1.stateVec.imag[i] - qureg2.stateVec.imag[i]) < precision);
             
     // if one node's partition wasn't equal, all-nodes must report not-equal
     int allAmpsAgree = ampsAgree;
 #ifdef DISTRIBUTED_MODE
     MPI_Allreduce(&ampsAgree, &allAmpsAgree, 1, MPI_INT, MPI_LAND, MPI_COMM_WORLD);
 #endif
  
     return allAmpsAgree;
 }

References copyStateFromGPU(), DEMAND, Qureg::isDensityMatrix, Qureg::numAmpsPerChunk, Qureg::numAmpsTotal, QUEST_ENV, Qureg::stateVec, and syncQuESTEnv().

◆ areEqual() [8/8]

bool areEqual	(	QVector	a,
		QVector	b
	)

Returns true if the absolute value of the difference between every amplitude in vectors a and b is less than REAL_EPS.

Author: Tyson Jones

Definition at line 387 of file utilities.cpp.

                                     {
     DEMAND( a.size() == b.size() );
     
     for (size_t i=0; i<a.size(); i++)
         if (abs(a[i] - b[i]) > REAL_EPS)
             return false;
     return true;
 }

References DEMAND.

Referenced by areEqual(), getRandomKrausMap(), getRandomUnitary(), and TEST_CASE().

◆ bitsets()

CatchGen<int*> bitsets ( int numBits )

Returns a Catch2 generator of every numBits-length bit-set, in increasing lexographic order, where left-most (zero index) bit is treated as LEAST significant (opposite typical convention).

Note that the produced bitset must not be modified during generation.

This function can be used like

int* bits = GENERATE( bitsets(3) );

to produce {0,0,0}, {1,0,0}, {0,1,0}, {1,1,0}, {0,0,1}, {1,0,1}, {0,1,1}, {1,1,1}.

Author: Tyson Jones

Definition at line 1143 of file utilities.cpp.

                                                            {    
     return Catch::Generators::GeneratorWrapper<int*>(
         std::unique_ptr<Catch::Generators::IGenerator<int*>>(
             new SequenceGenerator<int>(1, numBits)));
 }

Referenced by TEST_CASE().

◆ calcLog2()

unsigned int calcLog2 ( long unsigned int num )

Returns log2 of numbers which must be gauranteed to be 2^n.

Author: Tyson Jones

Returns log2 of numbers which must be gauranteed to be 2^n.

Definition at line 254 of file QuEST_validation.c.

                                              {
     unsigned int l = 0;
     while (num >>= 1)
         l++;
     return l;
 }

Referenced by applyReferenceOp(), TEST_CASE(), and validateNumQubitsInQureg().

◆ getConjugateTranspose()

QMatrix getConjugateTranspose ( QMatrix a )

Returns the conjugate transpose of the complex square matrix a.

Author: Tyson Jones

Definition at line 179 of file utilities.cpp.

                                          {
     QMatrix b = a;
     for (size_t r=0; r<a.size(); r++)
         for (size_t c=0; c<a.size(); c++)
             b[r][c] = conj(a[c][r]);
     return b;
 }

Referenced by applyReferenceOp(), getRandomKrausMap(), and getRandomUnitary().

◆ getExponentialOfDiagonalMatrix()

QMatrix getExponentialOfDiagonalMatrix ( QMatrix a )

Returns the matrix exponential of a diagonal, square, complex matrix.

This method explicitly checks that the passed matrix a is diagonal.

Author: Tyson Jones

Definition at line 187 of file utilities.cpp.

                                                   {
     
     // ensure diagonal
     for (size_t r=0; r<a.size(); r++)
         for (size_t c=0; c<a.size(); c++) {
             if (r == c)
                 continue;
             DEMAND( a[r][c] == 0. );
         }
  
     // exp(diagonal) = diagonal(exp)
     QMatrix diag = a;
     for (size_t i=0; i<a.size(); i++)
         diag[i][i] = exp(diag[i][i]);
         
     return diag;
 }

References DEMAND.

Referenced by TEST_CASE().

◆ getExponentialOfPauliMatrix()

QMatrix getExponentialOfPauliMatrix	(	qreal	angle,
		QMatrix	a
	)

Returns the matrix exponential of a kronecker product of pauli matrices (or of any involutory matrices), with exponent factor (-i angle / 2).

This method will not explicitly check that the passed matrix a is kronecker product of involutory matrices, but will otherwise return an incorrect exponential.

Author: Tyson Jones

Definition at line 205 of file utilities.cpp.

                                                             {
     QMatrix iden = getIdentityMatrix(a.size());
     QMatrix expo = (cos(angle/2) * iden) + (-1i * sin(angle/2) * a);
     return expo;
 }

References getIdentityMatrix().

Referenced by TEST_CASE().

◆ getFullOperatorMatrix()

QMatrix getFullOperatorMatrix	(	int *	ctrls,
		int	numCtrls,
		int *	targs,
		int	numTargs,
		QMatrix	op,
		int	numQubits
	)

Takes a 2^numTargs-by-2^numTargs matrix op and a returns a 2^numQubits-by-2^numQubits matrix where op is controlled on the given ctrls qubits.

The union of {ctrls} and {targs} must be unique (though this is not explicitly checked), and every element must be >= 0 (not checked). The passed {ctrls} and {targs} arrays are unmodified.

This funciton works by first swapping {targs} and {ctrls} (via swap unitaries) to be strictly increasing {0,1,...}, building controlled(op), tensoring it to the full Hilbert space, and then 'unswapping'. The returned matrix has form: swap1 ... swapN . controlled(op) . swapN ... swap1

Author: Tyson Jones

Definition at line 293 of file utilities.cpp.

   {        
     DEMAND( numCtrls >= 0 );
     DEMAND( numTargs >= 0 );
     DEMAND( numQubits >= (numCtrls+numTargs) );
     DEMAND( op.size() == (1u << numTargs) );
     
     // copy {ctrls} and {targs}to restore at end
     std::vector<int> ctrlsCopy(ctrls, ctrls+numCtrls);
     std::vector<int> targsCopy(targs, targs+numTargs);
     
     // full-state matrix of qubit swaps
     QMatrix swaps = getIdentityMatrix(1 << numQubits);
     QMatrix unswaps = getIdentityMatrix(1 << numQubits);
     QMatrix matr;
     
     // swap targs to {0, ..., numTargs-1}
     for (int i=0; i<numTargs; i++) {
         if (i != targs[i]) {
             matr = getSwapMatrix(i, targs[i], numQubits);
             swaps = matr * swaps;
             unswaps = unswaps * matr;
             
             // even if this is the last targ, ctrls might still need updating
             updateIndices(
                 i, targs[i], (i < numTargs-1)? &targs[i+1] : NULL, 
                 numTargs-i-1, ctrls, numCtrls);
         }
     }
  
     // swap ctrls to {numTargs, ..., numTargs+numCtrls-1}
     for (int i=0; i<numCtrls; i++) {
         int newInd = numTargs+i;
         if (newInd != ctrls[i]) {
             matr = getSwapMatrix(newInd, ctrls[i], numQubits);
             swaps = matr * swaps;
             unswaps = unswaps * matr;
             
             // update remaining ctrls (if any exist)
             if (i < numCtrls-1)
                 updateIndices(newInd, ctrls[i], NULL, 0, &ctrls[i+1], numCtrls-i-1);
         }
     }
     
     // construct controlled-op matrix for qubits {0, ..., numCtrls+numTargs-1}
     size_t dim = 1 << (numCtrls+numTargs);
     QMatrix fullOp = getIdentityMatrix(dim);
     setSubMatrix(fullOp, op, dim-op.size(), dim-op.size());
     
     // create full-state controlled-op matrix (left-pad identities)
     if (numQubits > numCtrls+numTargs) {
         size_t pad = 1 << (numQubits - numCtrls - numTargs);
         fullOp = getKroneckerProduct(getIdentityMatrix(pad), fullOp);
     }
     
     // apply swap to either side (to swap qubits back and forth)
     fullOp = unswaps * fullOp * swaps;
     
     // restore {ctrls and targs}
     for (int i=0; i<numCtrls; i++)
         ctrls[i] = ctrlsCopy[i];
     for (int i=0; i<numTargs; i++)
         targs[i] = targsCopy[i];
  
     return fullOp;
 }

References DEMAND, getIdentityMatrix(), getKroneckerProduct(), getSwapMatrix(), setSubMatrix(), and updateIndices().

Referenced by applyReferenceOp(), and TEST_CASE().

◆ getIdentityMatrix()

QMatrix getIdentityMatrix ( size_t dim )

Returns a dim-by-dim identity matrix.

Author: Tyson Jones

Definition at line 151 of file utilities.cpp.

                                       {
     DEMAND( dim > 1 );
     QMatrix matr = getZeroMatrix(dim);
     for (size_t i=0; i<dim; i++)
         matr[i][i] = 1;
     return matr;
 }

References DEMAND, and getZeroMatrix().

Referenced by getExponentialOfPauliMatrix(), getFullOperatorMatrix(), getRandomKrausMap(), getRandomUnitary(), and getSwapMatrix().

◆ getKetBra()

QMatrix getKetBra	(	QVector	ket,
		QVector	bra
	)

Returns the matrix |ket><bra|, with ith-jth element ket(i) conj(bra(j)), since |ket><bra| = sum_i a_i|i> sum_j b_j* <j| = sum_{ij} a_i b_j* |i><j|.

The dimensions of bra and ket must agree, and the returned square complex matrix has dimensions size(bra) x size(bra).

Author: Tyson Jones

Definition at line 159 of file utilities.cpp.

                                             {
     DEMAND( ket.size() == bra.size() );
     QMatrix mat = getZeroMatrix(ket.size());
     
     for (size_t r=0; r<ket.size(); r++)
         for (size_t c=0; c<ket.size(); c++)
             mat[r][c] = ket[r] * conj(bra[c]);
     return mat;
 }

References DEMAND, and getZeroMatrix().

Referenced by getRandomDensityMatrix(), and TEST_CASE().

◆ getKroneckerProduct()

QMatrix getKroneckerProduct	(	QMatrix	a,
		QMatrix	b
	)

Returns the kronecker product of a and b, where a and b are square but possibly differently-sized complex matrices.

Author: Tyson Jones

Definition at line 169 of file utilities.cpp.

                                                   {
     QMatrix prod = getZeroMatrix(a.size() * b.size());
     for (size_t r=0; r<b.size(); r++)
         for (size_t c=0; c<b.size(); c++)
             for (size_t i=0; i<a.size(); i++)
                 for (size_t j=0; j<a.size(); j++)
                     prod[r+b.size()*i][c+b.size()*j] = a[i][j] * b[r][c];
     return prod;
 }

References getZeroMatrix().

Referenced by getFullOperatorMatrix(), getSwapMatrix(), and TEST_CASE().

◆ getNormalised()

QVector getNormalised ( QVector vec )

Returns an L2-normalised copy of vec, using Kahan summation for improved accuracy.

Author: Tyson Jones

Definition at line 431 of file utilities.cpp.

                                    {
     qreal norm = 0;
     qreal y, t, c;
     c = 0;
     
     for (size_t i=0; i<vec.size(); i++) {
         y = real(vec[i])*real(vec[i]) - c;
         t = norm + y;
         c = ( t - norm ) - y;
         norm = t;
         
         y = imag(vec[i])*imag(vec[i]) - c;
         t = norm + y;
         c = ( t - norm ) - y;
         norm = t;
     }
     
     for (size_t i=0; i<vec.size(); i++)
         vec[i] /= sqrt(norm);
     return vec;
 }

References qreal.

Referenced by getRandomStateVector().

◆ getRandomDensityMatrix()

QMatrix getRandomDensityMatrix ( int numQb )

Returns a random numQb-by-numQb density matrix, from an undisclosed distribution, in a very mixed state.

This function works by generating 2^numQb random pure states, and mixing them with random probabilities.

Author: Tyson Jones

Definition at line 457 of file utilities.cpp.

                                           {
     DEMAND( numQb > 0 );
     
     // generate random probabilities to weight random pure states
     int dim = 1<<numQb;
     qreal probs[dim];
     qreal probNorm = 0;
     for (int i=0; i<dim; i++) {
         probs[i] = getRandomReal(0, 1);
         probNorm += probs[i];
     }
     for (int i=0; i<dim; i++)
         probs[i] /= probNorm;
     
     // add random pure states
     QMatrix dens = getZeroMatrix(dim);
     for (int i=0; i<dim; i++) {
         QVector pure = getRandomStateVector(numQb);
         dens += probs[i] * getKetBra(pure, pure);
     }
     
     return dens;
 }

References DEMAND, getKetBra(), getRandomReal(), getRandomStateVector(), getZeroMatrix(), and qreal.

Referenced by TEST_CASE().

◆ getRandomInt()

int getRandomInt	(	int	min,
		int	max
	)

Returns a random integer between min (inclusive) and max (exclusive), from the uniform distribution.

Demands that max > min.

Author: Tyson Jones

Definition at line 481 of file utilities.cpp.

                                    {
     return round(getRandomReal(min, max-1));
 }

References getRandomReal().

Referenced by TEST_CASE().

◆ getRandomKrausMap()

std::vector<QMatrix> getRandomKrausMap	(	int	numQb,
		int	numOps
	)

Returns a random Kraus map of #numOps 2^numQb-by-2^numQb operators, from an undisclosed distribution.

Note this method is very simple and cannot generate all possible Kraus maps. It works by generating numOps random unitary matrices, and randomly re-normalising them, such that the sum of ops[j]^dagger ops[j] = 1

Author: Tyson Jones

Definition at line 533 of file utilities.cpp.

                                                             {
     DEMAND( numOps >= 1 );
     DEMAND( numOps <= 4*numQb*numQb );
  
     // generate random unitaries
     std::vector<QMatrix> ops;
     for (int i=0; i<numOps; i++)
         ops.push_back(getRandomUnitary(numQb));
         
     // generate random weights
     qreal weights[numOps];
     for (int i=0; i<numOps; i++)
         weights[i] = getRandomReal(0, 1);
         
     // normalise random weights
     qreal weightSum = 0;
     for (int i=0; i<numOps; i++)
         weightSum += weights[i];
     for (int i=0; i<numOps; i++)
         weights[i] = sqrt(weights[i]/weightSum);
         
     // normalise ops
     for (int i=0; i<numOps; i++)
         ops[i] *= weights[i];
         
     // check what we produced was a valid Kraus map
     QMatrix iden = getIdentityMatrix(1 << numQb);
     QMatrix prodSum = getZeroMatrix(1 << numQb);
     for (int i=0; i<numOps; i++)
         prodSum += getConjugateTranspose(ops[i]) * ops[i];
     DEMAND( areEqual(prodSum, iden) );
         
     return ops;
 }

References areEqual(), DEMAND, getConjugateTranspose(), getIdentityMatrix(), getRandomReal(), getRandomUnitary(), getZeroMatrix(), and qreal.

Referenced by TEST_CASE().

◆ getRandomQMatrix()

QMatrix getRandomQMatrix ( int dim )

Returns a dim-by-dim complex matrix, where the real and imaginary value of each element are independently random, under the standard normal distribution (mean 0, standard deviation 1).

Author: Tyson Jones

Definition at line 368 of file utilities.cpp.

                                   {
     DEMAND( dim > 1 );
     
     QMatrix matr = getZeroMatrix(dim);
     for (int i=0; i<dim; i++) {
         for (int j=0; j<dim; j++) {
             
             // generate 2 normally-distributed random numbers via Box-Muller
             qreal a = rand()/(qreal) RAND_MAX;
             qreal b = rand()/(qreal) RAND_MAX;
             qreal r1 = sqrt(-2 * log(a)) * cos(2 * 3.14159265 * b);
             qreal r2 = sqrt(-2 * log(a)) * sin(2 * 3.14159265 * b);
             
             matr[i][j] = r1 + r2*1i;
         }
     }
     return matr;
 }

References DEMAND, getZeroMatrix(), and qreal.

Referenced by getRandomUnitary(), and TEST_CASE().

◆ getRandomQVector()

QVector getRandomQVector ( int dim )

Returns a dim-length vector with random complex amplitudes in the square joining {-1-i, 1+i}, of an undisclosed distribution.

The resulting vector is NOT L2-normalised.

Author: Tyson Jones

Definition at line 420 of file utilities.cpp.

                                   { 
     QVector vec = QVector(dim);
     for (int i=0; i<dim; i++)
         vec[i] = getRandomReal(-1,1) + 1i*getRandomReal(-1,1);
         
     // check we didn't get the impossibly-unlikely zero-amplitude outcome 
     DEMAND( real(vec[0]) != 0 );
         
     return vec;
 }

References DEMAND, and getRandomReal().

Referenced by getRandomStateVector(), and TEST_CASE().

◆ getRandomReal()

qreal getRandomReal	(	qreal	min,
		qreal	max
	)

Returns a random real between min (inclusive) and max (exclusive), from the uniform distribution.

Demands that max > min.

Author: Tyson Jones

Definition at line 410 of file utilities.cpp.

                                           {
     DEMAND( min <= max );
     qreal r = min + (max - min) * (rand() / (qreal) RAND_MAX);
     
     // check bounds satisfied 
     DEMAND( r >= min );
     DEMAND( r <= max );
     return r;
 }

References DEMAND, and qreal.

Referenced by getRandomDensityMatrix(), getRandomInt(), getRandomKrausMap(), getRandomQVector(), and TEST_CASE().

◆ getRandomStateVector()

QVector getRandomStateVector ( int numQb )

Returns a random numQb-length L2-normalised state-vector from an undisclosed distribution.

This function works by randomly generating each complex amplitude, then L2-normalising.

Author: Tyson Jones

Definition at line 453 of file utilities.cpp.

                                         {
     return getNormalised(getRandomQVector(1<<numQb));
 }

References getNormalised(), and getRandomQVector().

Referenced by getRandomDensityMatrix(), and TEST_CASE().

◆ getRandomUnitary()

QMatrix getRandomUnitary ( int numQb )

Returns a uniformly random (under Haar) 2^numQb-by-2^numQb unitary matrix.

This function works by first generating a complex matrix where each element is independently random; the real and imaginary component thereof are independent standard normally-distributed (mean 0, standard-dev 1). Then, the matrix is orthonormalised via the Gram Schmidt algorithm. The resulting unitary matrix MAY be uniformly distributed under the Haar measure, but we make no assurance. This routine may return an identity matrix if it was unable to sufficiently precisely produce a unitary of the given size.

Author: Tyson Jones

Definition at line 485 of file utilities.cpp.

                                     {
     DEMAND( numQb >= 1 );
  
     QMatrix matr = getRandomQMatrix(1 << numQb);
  
     for (size_t i=0; i<matr.size(); i++) {
         QVector row = matr[i];
         
         // compute new orthogonal row by subtracting proj row onto prevs
         for (int k=i-1; k>=0; k--) {
  
             // compute row . prev = sum_n row_n conj(prev_n)
             qcomp prod = 0;
             for (size_t n=0; n<row.size(); n++)
                 prod += row[n] * conj(matr[k][n]);
                             
             // subtract (proj row onto prev) = (prod * prev) from final row
             for (size_t n=0; n<row.size(); n++)
                 matr[i][n] -= prod * matr[k][n];
         }
     
         // compute row magnitude 
         qreal mag = 0;
         for (size_t j=0; j<row.size(); j++)
             mag += pow(abs(matr[i][j]), 2);
         mag = sqrt(mag);
         
         // normalise row
         for (size_t j=0; j<row.size(); j++)
             matr[i][j] /= mag;
     }
     
     // ensure matrix is indeed unitary 
     QMatrix conjprod = matr * getConjugateTranspose(matr);
     QMatrix iden = getIdentityMatrix(1 << numQb);
     
     // generating big unitary matrices is hard; if we fail, default to identity
     if ( numQb >= 3 && !areEqual(conjprod, iden) ) {
         
         matr = getIdentityMatrix(1 << numQb);
         conjprod = matr;
     }
     DEMAND( areEqual(conjprod, iden) );
     
     // return the new orthonormal matrix
     return matr;
 }

References areEqual(), DEMAND, getConjugateTranspose(), getIdentityMatrix(), getRandomQMatrix(), qcomp, and qreal.

Referenced by getRandomKrausMap(), and TEST_CASE().

◆ getSwapMatrix()

QMatrix getSwapMatrix	(	int	qb1,
		int	qb2,
		int	numQb
	)

Returns the 2^numQb-by-2^numQb unitary matrix which swaps qubits qb1 and qb2; the SWAP gate of not-necessarily-adjacent qubits.

If qb1 == qb2, returns the identity matrix.

Author: Tyson Jones

Definition at line 219 of file utilities.cpp.

                                                    {
     DEMAND( numQb > 1 );
     DEMAND( (qb1 >= 0 && qb1 < numQb) );
     DEMAND( (qb2 >= 0 && qb2 < numQb) );
     
     if (qb1 > qb2)
         std::swap(qb1, qb2);
         
     if (qb1 == qb2)
         return getIdentityMatrix(1 << numQb);
  
     QMatrix swap;
     
     if (qb2 == qb1 + 1) {
         // qubits are adjacent
         swap = QMatrix{{1,0,0,0},{0,0,1,0},{0,1,0,0},{0,0,0,1}};
         
     } else {
         // qubits are distant
         int block = 1 << (qb2 - qb1);
         swap = getZeroMatrix(block*2);
         QMatrix iden = getIdentityMatrix(block/2);
         
         // Lemma 3.1 of arxiv.org/pdf/1711.09765.pdf
         QMatrix p0{{1,0},{0,0}};
         QMatrix l0{{0,1},{0,0}};
         QMatrix l1{{0,0},{1,0}};
         QMatrix p1{{0,0},{0,1}};
         
         /* notating a^(n+1) = identity(1<<n) (otimes) a, we construct the matrix
          * [ p0^(N) l1^N ]
          * [ l0^(N) p1^N ]
          * where N = qb2 - qb1 */
         setSubMatrix(swap, getKroneckerProduct(iden, p0), 0, 0);
         setSubMatrix(swap, getKroneckerProduct(iden, l0), block, 0);
         setSubMatrix(swap, getKroneckerProduct(iden, l1), 0, block);
         setSubMatrix(swap, getKroneckerProduct(iden, p1), block, block);
     }
     
     // pad swap with outer identities
     if (qb1 > 0)
         swap = getKroneckerProduct(swap, getIdentityMatrix(1<<qb1));
     if (qb2 < numQb-1)
         swap = getKroneckerProduct(getIdentityMatrix(1<<(numQb-qb2-1)), swap);
         
     return swap;
 }

References DEMAND, getIdentityMatrix(), getKroneckerProduct(), getZeroMatrix(), and setSubMatrix().

Referenced by getFullOperatorMatrix().

◆ getZeroMatrix()

QMatrix getZeroMatrix ( size_t dim )

Returns a dim-by-dim square complex matrix, initialised to all zeroes.

Author: Tyson Jones

Definition at line 143 of file utilities.cpp.

                                   {
     DEMAND( dim > 1 );
     QMatrix matr = QMatrix(dim);
     for (size_t i=0; i<dim; i++)
         matr[i].resize(dim);
     return matr;
 }

References DEMAND.

Referenced by getIdentityMatrix(), getKetBra(), getKroneckerProduct(), getRandomDensityMatrix(), getRandomKrausMap(), getRandomQMatrix(), getSwapMatrix(), TEST_CASE(), and toQMatrix().

◆ pauliseqs()

CatchGen<pauliOpType*> pauliseqs ( int numPaulis )

Returns a Catch2 generator of every numPaulis-length set of Pauli-matrix types (or base-4 integers).

Generates in increasing lexographic order, where the left-most (zero index) pauli is treated as LEAST significant. Note that the sequence must not be modified during generation.

This function can be used like

pauliOpType* set = GENERATE( pauliseqs(2) );

to produce {I,I}, {X,I}, {Y,I}, {Z,I}, {I,X}, {X,X}, {Y,X}, {Z,X}, {I,Y}, {X,Y}, {Y,Y}, {Z,Y}, {I,Z}, {X,Z}, {Y,Z}, {Z,Z}/

Author: Tyson Jones

Definition at line 1153 of file utilities.cpp.

                                                                        {    
     return Catch::Generators::GeneratorWrapper<pauliOpType*>(
         std::unique_ptr<Catch::Generators::IGenerator<pauliOpType*>>(
             new SequenceGenerator<pauliOpType>(PAULI_Z, numPaulis)));
 }

References PAULI_Z.

◆ sequences()

CatchGen<int*> sequences	(	int	base,
		int	numDigits
	)

Returns a Catch2 generator of every numDigits-length sequence in the given base, in increasing lexographic order, where left-most (zero index) bit is treated as LEAST significant (opposite typical convention).

Note that the sequence must not be modified during generation.

This function can be used like

int base = 3;
int numDigits = 2;
int* seq = GENERATE_COPY( sequences(base, numDigits) );

to produce {0,0}, {1,0}, {2,0}, {0,1}, {1,1}, {2,1}, {0,2}, {1,2}, {2,2}.

Author: Tyson Jones

Definition at line 1148 of file utilities.cpp.

                                                                          {    
     return Catch::Generators::GeneratorWrapper<int*>(
         std::unique_ptr<Catch::Generators::IGenerator<int*>>(
             new SequenceGenerator<int>(base-1, numDigits)));
 }

◆ setSubMatrix()

void setSubMatrix	(	QMatrix &	dest,
		QMatrix	sub,
		size_t	r,
		size_t	c
	)

Modifies dest by overwriting its submatrix (from top-left corner (r, c) to bottom-right corner (r + dest.size(), c + dest.size()) with the complete elements of sub.

This demands that dest.size() >= sub.size() + max(r,c).

Author: Tyson Jones

Definition at line 211 of file utilities.cpp.

                                                                   {
     DEMAND( sub.size() + r <= dest.size() );
     DEMAND( sub.size() + c <= dest.size() );
     for (size_t i=0; i<sub.size(); i++)
         for (size_t j=0; j<sub.size(); j++)
             dest[r+i][c+j] = sub[i][j];
 }

References DEMAND.

Referenced by getFullOperatorMatrix(), and getSwapMatrix().

◆ sublists() [1/4]

CatchGen<int*> sublists	(	CatchGen< int > &&	gen,
		int	numSamps,
		const int *	exclude,
		int	numExclude
	)

Returns a Catch2 generator of every length-sublen sublist of the elements generated by gen, which exclude all elements in exclude, in increasing lexographic order.

This generates every fixed-length combination of gen's elements the nominated exclusions, and every permutation of each.

There is on need for the elements of exclude to actually appear in those of gen. sublen must less than or equal to the number of elements in gen, after the nominated exclusions.

Note that the sublist must not be modified, else further generation may break (QuEST's internal functions will indeed modify but restore the qubit index lists given to them, which is ok). Assumes list contains no duplicates, otherwise the generated sublists may be duplicated.

This function can be used like

int sublen = 2;
int exclude[2] = {3,4};
int* sublist = GENERATE_COPY( sublists(range(1,6), sublen, exclude, 2) );

to generate {1,2}, {1,5}, {2,1}, {2,5}, {5,1}, {5,2}

Author: Tyson Jones

◆ sublists() [2/4]

CatchGen<int*> sublists	(	CatchGen< int > &&	gen,
		int	numSamps,
		int	excluded
	)

Returns a Catch2 generator of every length-sublen sublist of the elements generated by gen which exclude element excluded, in increasing lexographic order.

This generates every fixed-length combination of gen's elements the nominated exclusions, and every permutation of each.

sublen must less than or equal to the number of elements in gen, after the nominated exclusion. There is no need for excluded to actually appear in the elements of gen.

Note that the sublist must not be modified, else further generation may break (QuEST's internal functions will indeed modify but restore the qubit index lists given to them, which is ok). Assumes list contains no duplicates, otherwise the generated sublists may be duplicated.

This function can be used like

int sublen = 2;
int excluded = 1;
int* sublist = GENERATE_COPY( sublists(range(1,4), sublen, excluded) );

to generate {2,3}, {3,2}.

Author: Tyson Jones

◆ sublists() [3/4]

CatchGen<int*> sublists	(	CatchGen< int > &&	gen,
		int	sublen
	)

Returns a Catch2 generator of every length-sublen sublist of the elements generated by gen, in increasing lexographic order.

This generates every fixed-length combination of gen's elements, and every permutation of each. Note that the produced sublist must not be modified, else further generation may break (QuEST's internal functions will indeed modify but restore the qubit index lists given to them, which is ok). Assumes list contains no duplicates, otherwise the generated sublists may be duplicated.

This function can be used like

int sublen = 2;
int* sublist = GENERATE_COPY( sublists(list, 4, sublen) );

to generate {1,2}, {1,3}, {1,4}, {2,1}, {2,3}, {2,4}, {3,1}, {3,2}, {3, 4}, {4,1}, {4,2}, {4, 3}.

Author: Tyson Jones

◆ sublists() [4/4]

CatchGen<int*> sublists	(	int *	list,
		int	len,
		int	sublen
	)

Returns a Catch2 generator of every length-sublen sublist of length-len list, in increasing lexographic order.

This generates every fixed-length combination of the given list and every permutation of each. & If the sublist length is the full list length, this generator produces every permutation correctly. Note that the sublist must not be modified, else further & generation may break (QuEST's internal functions will indeed modify but restore the qubit index lists given to them, which is ok). Assumes list contains no duplicates, otherwise the generated sublists may be duplicated.

This function can be used like

int list[4] = {1,2,3,4};
int sublen = 2;
int* sublist = GENERATE_COPY( sublists(list, 4, sublen) );

to generate {1,2}, {1,3}, {1,4}, {2,1}, {2,3}, {2,4}, {3,1}, {3,2}, {3, 4}, {4,1}, {4,2}, {4, 3}.

Author: Tyson Jones

Definition at line 1074 of file utilities.cpp.

   {    
     return Catch::Generators::GeneratorWrapper<int*>(
         std::unique_ptr<Catch::Generators::IGenerator<int*>>(
             new SubListGenerator(list, len, sublen)));
 }

Referenced by TEST_CASE().

◆ toComplexMatrix2()

ComplexMatrix2 toComplexMatrix2 ( QMatrix qm )

Returns a ComplexMatrix2 copy of QMatix qm.

Demands that qm is a 2-by-2 matrix.

Author: Tyson Jones

Definition at line 812 of file utilities.cpp.

                                             {
     DEMAND( qm.size() == 2 );
     ComplexMatrix2 cm;
     macro_copyQMatrix(cm, qm);
     return cm;
 }

References DEMAND, and macro_copyQMatrix.

Referenced by TEST_CASE().

◆ toComplexMatrix4()

ComplexMatrix4 toComplexMatrix4 ( QMatrix qm )

Returns a ComplexMatrix4 copy of QMatix qm.

Demands that qm is a 4-by-4 matrix.

Author: Tyson Jones

Definition at line 818 of file utilities.cpp.

                                             {
     DEMAND( qm.size() == 4 );
     ComplexMatrix4 cm;
     macro_copyQMatrix(cm, qm);
     return cm;
 }

References DEMAND, and macro_copyQMatrix.

Referenced by TEST_CASE().

◆ toComplexMatrixN()

void toComplexMatrixN	(	QMatrix	qm,
		ComplexMatrixN	cm
	)

Initialises cm with the values of qm.

Demands that cm is a previously created ComplexMatrixN instance, with the same dimensions as qm.

Author: Tyson Jones

Definition at line 824 of file utilities.cpp.

                                                      {
     DEMAND( qm.size() == (1u<<cm.numQubits) );
     macro_copyQMatrix(cm, qm);
 }

References DEMAND, macro_copyQMatrix, and ComplexMatrixN::numQubits.

Referenced by TEST_CASE().

◆ toQMatrix() [1/5]

QMatrix toQMatrix	(	Complex	alpha,
		Complex	beta
	)

Returns the matrix (where a=alpha, b=beta) {{a, -conj(b)}, {b, conj(a)}} using the qcomp complex type.

Author: Tyson Jones

Definition at line 853 of file utilities.cpp.

                                                {
     qcomp a = qcomp(alpha.real, alpha.imag);
     qcomp b = qcomp(beta.real, beta.imag);
     QMatrix matr{
         {a, -conj(b)},
         {b,  conj(a)}};
     return matr;
 }

References Complex::imag, qcomp, and Complex::real.

◆ toQMatrix() [2/5]

QMatrix toQMatrix ( ComplexMatrix2 src )

Returns a copy of the given 2-by-2 matrix.

Author: Tyson Jones

Definition at line 835 of file utilities.cpp.

                                       {
     QMatrix dest = getZeroMatrix(2);
     macro_copyComplexMatrix(dest, src);
     return dest;
 }

References getZeroMatrix(), and macro_copyComplexMatrix.

Referenced by TEST_CASE().

◆ toQMatrix() [3/5]

QMatrix toQMatrix ( ComplexMatrix4 src )

Returns a copy of the given 4-by-4 matrix.

Author: Tyson Jones

Definition at line 840 of file utilities.cpp.

                                       {
     QMatrix dest = getZeroMatrix(4);
     macro_copyComplexMatrix(dest, src);
     return dest;
 }

References getZeroMatrix(), and macro_copyComplexMatrix.

◆ toQMatrix() [4/5]

QMatrix toQMatrix ( ComplexMatrixN src )

Returns a copy of the given 2^N-by-2^n matrix.

Author: Tyson Jones

Definition at line 845 of file utilities.cpp.

                                       {
     DEMAND( src.real != NULL );
     DEMAND( src.imag != NULL );
     QMatrix dest = getZeroMatrix(1 << src.numQubits);
     macro_copyComplexMatrix(dest, src);
     return dest;
 }

References DEMAND, getZeroMatrix(), ComplexMatrixN::imag, macro_copyComplexMatrix, ComplexMatrixN::numQubits, and ComplexMatrixN::real.

◆ toQMatrix() [5/5]

QMatrix toQMatrix ( Qureg qureg )

Returns an equal-size copy of the given density matrix qureg.

In GPU mode, this function involves a copy of qureg from GPU memory to RAM. In distributed mode, this involves an all-to-all broadcast of qureg.

Author: Tyson Jones

Definition at line 862 of file utilities.cpp.

                                {
     DEMAND( qureg.isDensityMatrix );
 #ifdef DISTRIBUTED_MODE
     DEMAND( qureg.numAmpsTotal < MPI_MAX_AMPS_IN_MSG );
 #endif
     
     // ensure local qureg.stateVec is up to date
     copyStateFromGPU(qureg);
     syncQuESTEnv(QUEST_ENV);
     
     qreal* fullRe;
     qreal* fullIm;
     
     // in distributed mode, give every node the full state vector
 #ifdef DISTRIBUTED_MODE
     fullRe = (qreal*) malloc(qureg.numAmpsTotal * sizeof *fullRe);
     fullIm = (qreal*) malloc(qureg.numAmpsTotal * sizeof *fullIm);
     MPI_Allgather(
         qureg.stateVec.real, qureg.numAmpsPerChunk, MPI_QuEST_REAL,
         fullRe, qureg.numAmpsPerChunk, MPI_QuEST_REAL, MPI_COMM_WORLD);
     MPI_Allgather(
         qureg.stateVec.imag, qureg.numAmpsPerChunk, MPI_QuEST_REAL,
         fullIm, qureg.numAmpsPerChunk, MPI_QuEST_REAL, MPI_COMM_WORLD);
 #else
     fullRe = qureg.stateVec.real;
     fullIm = qureg.stateVec.imag;
 #endif
         
     // copy full state vector into a QVector
     long long int dim = (1 << qureg.numQubitsRepresented);
     QMatrix matr = getZeroMatrix(dim);
     for (long long int n=0; n<qureg.numAmpsTotal; n++)
         matr[n%dim][n/dim] = qcomp(fullRe[n], fullIm[n]);
     
     // clean up if we malloc'd the distributed array
 #ifdef DISTRIBUTED_MODE
     free(fullRe);
     free(fullIm);
 #endif
     return matr;
 }

References copyStateFromGPU(), DEMAND, getZeroMatrix(), Qureg::isDensityMatrix, Qureg::numAmpsPerChunk, Qureg::numAmpsTotal, Qureg::numQubitsRepresented, qcomp, qreal, QUEST_ENV, Qureg::stateVec, and syncQuESTEnv().

◆ toQureg() [1/2]

void toQureg	(	Qureg	qureg,
		QMatrix	mat
	)

Initialises the density matrix qureg to have the same amplitudes as mat.

Demands qureg is a density matrix of equal dimensions to mat. In GPU mode, this function involves a copy from RAM to GPU memory. This function has no communication cost in distributed mode.

Author: Tyson Jones

Definition at line 959 of file utilities.cpp.

                                        {
     DEMAND( qureg.isDensityMatrix );
     DEMAND( (1 << qureg.numQubitsRepresented) == (int) mat.size() );
     
     syncQuESTEnv(QUEST_ENV);
     
     int len = (1 << qureg.numQubitsRepresented);
     for (int i=0; i<qureg.numAmpsPerChunk; i++) {
         int ind = qureg.chunkId*qureg.numAmpsPerChunk + i;
         qureg.stateVec.real[i] = real(mat[ind%len][ind/len]);
         qureg.stateVec.imag[i] = imag(mat[ind%len][ind/len]);
     }
     copyStateToGPU(qureg);
 }

References Qureg::chunkId, copyStateToGPU(), DEMAND, Qureg::isDensityMatrix, Qureg::numAmpsPerChunk, Qureg::numQubitsRepresented, QUEST_ENV, Qureg::stateVec, and syncQuESTEnv().

◆ toQureg() [2/2]

void toQureg	(	Qureg	qureg,
		QVector	vec
	)

Initialises the state-vector qureg to have the same amplitudes as vec.

Demands qureg is a state-vector of an equal size to vec. In GPU mode, this function involves a copy from RAM to GPU memory. This function has no communication cost in distributed mode.

Author: Tyson Jones

Definition at line 946 of file utilities.cpp.

                                        {
     DEMAND( !qureg.isDensityMatrix );
     DEMAND( qureg.numAmpsTotal == (int) vec.size() );
     
     syncQuESTEnv(QUEST_ENV);
     
     for (int i=0; i<qureg.numAmpsPerChunk; i++) {
         int ind = qureg.chunkId*qureg.numAmpsPerChunk + i;
         qureg.stateVec.real[i] = real(vec[ind]);
         qureg.stateVec.imag[i] = imag(vec[ind]);
     }
     copyStateToGPU(qureg);
 }

References Qureg::chunkId, copyStateToGPU(), DEMAND, Qureg::isDensityMatrix, Qureg::numAmpsPerChunk, Qureg::numAmpsTotal, QUEST_ENV, Qureg::stateVec, and syncQuESTEnv().

Referenced by TEST_CASE().

◆ toQVector()

QVector toQVector ( Qureg qureg )

Returns an equal-size copy of the given state-vector qureg.

In GPU mode, this function involves a copy of qureg from GPU memory to RAM. In distributed mode, this involves an all-to-all broadcast of qureg.

Author: Tyson Jones

Definition at line 904 of file utilities.cpp.

                                {
     DEMAND( !qureg.isDensityMatrix );
 #ifdef DISTRIBUTED_MODE
     DEMAND( qureg.numAmpsTotal < MPI_MAX_AMPS_IN_MSG );
 #endif
     
     // ensure local qureg.stateVec is up to date
     copyStateFromGPU(qureg);
     syncQuESTEnv(QUEST_ENV);
     
     qreal* fullRe;
     qreal* fullIm;
     
     // in distributed mode, give every node the full state vector
 #ifdef DISTRIBUTED_MODE
     fullRe = (qreal*) malloc(qureg.numAmpsTotal * sizeof *fullRe);
     fullIm = (qreal*) malloc(qureg.numAmpsTotal * sizeof *fullIm);
             
     MPI_Allgather(
         qureg.stateVec.real, qureg.numAmpsPerChunk, MPI_QuEST_REAL,
         fullRe, qureg.numAmpsPerChunk, MPI_QuEST_REAL, MPI_COMM_WORLD);
     MPI_Allgather(
         qureg.stateVec.imag, qureg.numAmpsPerChunk, MPI_QuEST_REAL,
         fullIm, qureg.numAmpsPerChunk, MPI_QuEST_REAL, MPI_COMM_WORLD);
 #else
     fullRe = qureg.stateVec.real;
     fullIm = qureg.stateVec.imag;
 #endif
     
     // copy full state vector into a QVector
     QVector vec = QVector(qureg.numAmpsTotal);
     for (long long int i=0; i<qureg.numAmpsTotal; i++)
         vec[i] = qcomp(fullRe[i], fullIm[i]);
             
     // clean up if we malloc'd distrib array
 #ifdef DISTRIBUTED_MODE
     free(fullRe);
     free(fullIm);
 #endif
     return vec;
 }

References copyStateFromGPU(), DEMAND, Qureg::isDensityMatrix, Qureg::numAmpsPerChunk, Qureg::numAmpsTotal, qcomp, qreal, QUEST_ENV, Qureg::stateVec, and syncQuESTEnv().

Referenced by TEST_CASE().

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ QMatrix

◆ QVector

Function Documentation

◆ applyReferenceOp() [1/16]

◆ applyReferenceOp() [2/16]

◆ applyReferenceOp() [3/16]

◆ applyReferenceOp() [4/16]

◆ applyReferenceOp() [5/16]

◆ applyReferenceOp() [6/16]

◆ applyReferenceOp() [7/16]

◆ applyReferenceOp() [8/16]

◆ applyReferenceOp() [9/16]

◆ applyReferenceOp() [10/16]

◆ applyReferenceOp() [11/16]

◆ applyReferenceOp() [12/16]

◆ applyReferenceOp() [13/16]

◆ applyReferenceOp() [14/16]

◆ applyReferenceOp() [15/16]

◆ applyReferenceOp() [16/16]

◆ areEqual() [1/8]

◆ areEqual() [2/8]

◆ areEqual() [3/8]

◆ areEqual() [4/8]

◆ areEqual() [5/8]

◆ areEqual() [6/8]

◆ areEqual() [7/8]

◆ areEqual() [8/8]

◆ bitsets()

◆ calcLog2()

◆ getConjugateTranspose()

◆ getExponentialOfDiagonalMatrix()

◆ getExponentialOfPauliMatrix()

◆ getFullOperatorMatrix()

◆ getIdentityMatrix()

◆ getKetBra()

◆ getKroneckerProduct()

◆ getNormalised()

◆ getRandomDensityMatrix()

◆ getRandomInt()

◆ getRandomKrausMap()

◆ getRandomQMatrix()

◆ getRandomQVector()

◆ getRandomReal()

◆ getRandomStateVector()

◆ getRandomUnitary()

◆ getSwapMatrix()

◆ getZeroMatrix()

◆ pauliseqs()

◆ sequences()

◆ setSubMatrix()

◆ sublists() [1/4]

◆ sublists() [2/4]

◆ sublists() [3/4]

◆ sublists() [4/4]

◆ toComplexMatrix2()

◆ toComplexMatrix4()

◆ toComplexMatrixN()

◆ toQMatrix() [1/5]

◆ toQMatrix() [2/5]

◆ toQMatrix() [3/5]

◆ toQMatrix() [4/5]

◆ toQMatrix() [5/5]

◆ toQureg() [1/2]

◆ toQureg() [2/2]

◆ toQVector()