The core of the QuEST Library. More...

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "QuEST_precision.h"
#include "QuEST.h"
#include "QuEST_internal.h"
#include "mt19937ar.h"
#include <sys/param.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>

Macros
#define	DEBUG 0

Functions
void	reportState (MultiQubit multiQubit)
	Print the current state vector of probability amplitudes for a set of qubits to file. More...

void	reportMultiQubitParams (MultiQubit multiQubit)
	Report metainformation about a set of qubits: number of qubits, number of probability amplitudes. More...

void	rotateAroundAxis (MultiQubit multiQubit, const int rotQubit, REAL angle, Vector axis)
	Rotate a single qubit by a given angle around a given vector on the Bloch-sphere. More...

void	rotateX (MultiQubit multiQubit, const int rotQubit, REAL angle)
	Rotate a single qubit by a given angle around the X-axis of the Bloch-sphere. More...

void	rotateY (MultiQubit multiQubit, const int rotQubit, REAL angle)
	Rotate a single qubit by a given angle around the Y-axis of the Bloch-sphere. More...

void	rotateZ (MultiQubit multiQubit, const int rotQubit, REAL angle)
	Rotate a single qubit by a given angle around the Z-axis of the Bloch-sphere (also known as a phase shift gate). More...

void	controlledRotateAroundAxis (MultiQubit multiQubit, const int controlQubit, const int targetQubit, REAL angle, Vector axis)
	Applies a controlled rotation by a given angle around a given vector on the Bloch-sphere. More...

void	controlledRotateX (MultiQubit multiQubit, const int controlQubit, const int targetQubit, REAL angle)
	Applies a controlled rotation by a given angle around the X-axis of the Bloch-sphere. More...

void	controlledRotateY (MultiQubit multiQubit, const int controlQubit, const int targetQubit, REAL angle)
	Applies a controlled rotation by a given angle around the Y-axis of the Bloch-sphere. More...

void	controlledRotateZ (MultiQubit multiQubit, const int controlQubit, const int targetQubit, REAL angle)
	Applies a controlled rotation by a given angle around the Z-axis of the Bloch-sphere. More...

void	sigmaZ (MultiQubit multiQubit, const int targetQubit)
	Apply the single-qubit sigma-Z (also known as the Z, Pauli-Z or phase-flip) gate. More...

void	sGate (MultiQubit multiQubit, const int targetQubit)
	Apply the single-qubit S gate. More...

void	tGate (MultiQubit multiQubit, const int targetQubit)
	Apply the single-qubit T gate. More...

int	validateMatrixIsUnitary (ComplexMatrix2 u)

int	validateAlphaBeta (Complex alpha, Complex beta)

int	validateUnitVector (REAL ux, REAL uy, REAL uz)

void	QuESTSeedRandomDefault ()
	Seed the Mersenne Twister used for random number generation in the QuEST environment with an example defualt seed. More...

void	QuESTSeedRandom (unsigned long int *seedArray, int numSeeds)
	numSeeds <= 64 More...

unsigned long int	hashString (char *str)

Variables
const char *	errorCodes []

Detailed Description

The core of the QuEST Library.

Definition in file QuEST.cpp.

Macro Definition Documentation

◆ DEBUG

#define DEBUG 0

Definition at line 22 of file QuEST.cpp.

Function Documentation

◆ controlledRotateAroundAxis()

void controlledRotateAroundAxis	(	MultiQubit	multiQubit,
		const int	controlQubit,
		const int	targetQubit,
		REAL	angle,
		Vector	axis
	)

Applies a controlled rotation by a given angle around a given vector on the Bloch-sphere.

The vector must not be zero (else an error is thrown), but needn't be unit magnitude.

For angle $\theta$ and axis vector $\vec{n}$ , applies $R_{\hat{n}} = \exp \left(- i \frac{\theta}{2} \hat{n} \cdot \vec{\sigma} \right)$ to states where the target qubit is 1 ( $\vec{\sigma}$ is the vector of Pauli matrices).

$\setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {control}; \node[draw=none] at (-3.5, 0) {target}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_{\hat{n}}(\theta)$}; \end{tikzpicture} }$

Parameters

[in,out]	multiQubit	object representing the set of all qubits
[in]	controlQubit	qubit with value 1 in the rotated states
[in]	targetQubit	qubit to rotate
[in]	angle	angle by which to rotate in radians
[in]	axis	vector around which to rotate (can be non-unit; will be normalised)

Exceptions

exitWithError if either controlQubit or targetQubit are outside [0, multiQubit.numQubits) or are equal or if axis is the zero vector

Definition at line 122 of file QuEST.cpp.

References controlledCompactUnitary(), Complex::imag, Complex::real, Vector::x, Vector::y, and Vector::z.

Referenced by controlledRotateX(), controlledRotateY(), and controlledRotateZ().

                                                                                                                               {
 
     double mag = sqrt(pow(axis.x,2) + pow(axis.y,2) + pow(axis.z,2));
     Vector unitAxis = {axis.x/mag, axis.y/mag, axis.z/mag};
 
     Complex alpha, beta;
     alpha.real = cos(angle/2.0);
     alpha.imag = -sin(angle/2.0)*unitAxis.z;    
     beta.real = sin(angle/2.0)*unitAxis.y;
     beta.imag = -sin(angle/2.0)*unitAxis.x;
     controlledCompactUnitary(multiQubit, controlQubit, targetQubit, alpha, beta);
 }

◆ controlledRotateX()

void controlledRotateX	(	MultiQubit	multiQubit,
		const int	controlQubit,
		const int	targetQubit,
		REAL	angle
	)

Applies a controlled rotation by a given angle around the X-axis of the Bloch-sphere.

The target qubit is rotated in states where the control qubit has value 1.

$\setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {control}; \node[draw=none] at (-3.5, 0) {target}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_x(\theta)$}; \end{tikzpicture} }$

Parameters

[in,out]	multiQubit	object representing the set of all qubits
[in]	controlQubit	qubit which has value 1 in the rotated states
[in]	tagretQubit	qubit to rotate
[in]	angle	angle by which to rotate the target qubit in radians

Exceptions

exitWithError if either controlQubit or targetQubit are outside [0, multiQubit.numQubits) or are equal.

Definition at line 135 of file QuEST.cpp.

References controlledRotateAroundAxis().

                                                                                                         {
 
     Vector unitAxis = {1, 0, 0};
     controlledRotateAroundAxis(multiQubit, controlQubit, targetQubit, angle, unitAxis);
 }

◆ controlledRotateY()

void controlledRotateY	(	MultiQubit	multiQubit,
		const int	controlQubit,
		const int	targetQubit,
		REAL	angle
	)

Applies a controlled rotation by a given angle around the Y-axis of the Bloch-sphere.

The target qubit is rotated in states where the control qubit has value 1.

$\setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {control}; \node[draw=none] at (-3.5, 0) {target}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_y(\theta)$}; \end{tikzpicture} }$

Parameters

[in,out]	multiQubit	object representing the set of all qubits
[in]	controlQubit	qubit which has value 1 in the rotated states
[in]	tagretQubit	qubit to rotate
[in]	angle	angle by which to rotate the target qubit in radians

Exceptions

exitWithError if either controlQubit or targetQubit are outside [0, multiQubit.numQubits) or are equal.

Definition at line 141 of file QuEST.cpp.

References controlledRotateAroundAxis().

                                                                                                         {
 
     Vector unitAxis = {0, 1, 0};
     controlledRotateAroundAxis(multiQubit, controlQubit, targetQubit, angle, unitAxis);
 }

◆ controlledRotateZ()

void controlledRotateZ	(	MultiQubit	multiQubit,
		const int	controlQubit,
		const int	targetQubit,
		REAL	angle
	)

Applies a controlled rotation by a given angle around the Z-axis of the Bloch-sphere.

The target qubit is rotated in states where the control qubit has value 1.

$\setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 2) {control}; \node[draw=none] at (-3.5, 0) {target}; \draw (-2, 2) -- (2, 2); \draw[fill=black] (0, 2) circle (.2); \draw (0, 2) -- (0, 1); \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_z(\theta)$}; \end{tikzpicture} }$

Parameters

[in,out]	multiQubit	object representing the set of all qubits
[in]	controlQubit	qubit which has value 1 in the rotated states
[in]	tagretQubit	qubit to rotate
[in]	angle	angle by which to rotate the target qubit in radians

Exceptions

exitWithError if either controlQubit or targetQubit are outside [0, multiQubit.numQubits) or are equal.

Definition at line 147 of file QuEST.cpp.

References controlledRotateAroundAxis().

                                                                                                         {
 
     Vector unitAxis = {0, 0, 1};
     controlledRotateAroundAxis(multiQubit, controlQubit, targetQubit, angle, unitAxis);
 }

◆ hashString()

unsigned long int hashString ( char * str )

Definition at line 238 of file QuEST.cpp.

Referenced by QuESTSeedRandomDefault().

                                        {
     unsigned long int hash = 5381;
     int c;
 
     while ((c = *str++))
         hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
 
     return hash;    
 }

◆ QuESTSeedRandom()

void QuESTSeedRandom	(	unsigned long int *	seedArray,
		int	numSeeds
	)

numSeeds <= 64

Seed the Mersenne Twister used for random number generation in the QuEST environment with a user defined seed.

Definition at line 231 of file QuEST.cpp.

References init_by_array().

                                                                 {
     // init MT random number generator with user defined list of seeds
     // for the MPI version, it is ok that all procs will get the same seed as random numbers will only be 
     // used by the master process
     init_by_array(seedArray, numSeeds); 
 }

◆ QuESTSeedRandomDefault()

void QuESTSeedRandomDefault ( void )

Seed the Mersenne Twister used for random number generation in the QuEST environment with an example defualt seed.

This default seeding function uses the mt19937 init_by_array function with three keys – time, pid and hostname. Subsequent calls to mt19937 genrand functions will use this seeding. For a multi process code, the same seed is given to all process, therefore this seeding is only appropriate to use for functions such as measure where all processes require the same random value.

For more information about the MT, see http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html

Definition at line 206 of file QuEST.cpp.

References hashString(), and init_by_array().

                              {
     // init MT random number generator with three keys -- time, pid and a hash of hostname 
     // for the MPI version, it is ok that all procs will get the same seed as random numbers will only be 
     // used by the master process
 
     struct timeval  tv;
     gettimeofday(&tv, NULL);
 
     double time_in_mill = 
         (tv.tv_sec) * 1000 + (tv.tv_usec) / 1000 ; // convert tv_sec & tv_usec to millisecond
 
     unsigned long int pid = getpid();
     unsigned long int msecs = (unsigned long int) time_in_mill;
     char hostName[MAXHOSTNAMELEN+1];
     gethostname(hostName, sizeof(hostName));
     unsigned long int hostNameInt = hashString(hostName);
 
     unsigned long int key[3];
     key[0] = msecs; key[1] = pid; key[2] = hostNameInt;
     init_by_array(key, 3); 
 }

◆ reportMultiQubitParams()

void reportMultiQubitParams ( MultiQubit multiQubit )

Report metainformation about a set of qubits: number of qubits, number of probability amplitudes.

Parameters

[in,out]	multiQubit	object representing the set of qubits
[in]	env	object representing the execution environment (local, multinode etc)

Definition at line 80 of file QuEST.cpp.

References MultiQubit::chunkId, MultiQubit::numChunks, and MultiQubit::numQubits.

                                                   {
         long long int numAmps = 1L << multiQubit.numQubits;
         long long int numAmpsPerRank = numAmps/multiQubit.numChunks;
         if (multiQubit.chunkId==0){
                 printf("QUBITS:\n");
                 printf("Number of qubits is %d.\n", multiQubit.numQubits);
                 printf("Number of amps is %lld.\n", numAmps);
                 printf("Number of amps per rank is %lld.\n", numAmpsPerRank);
     }
 }

◆ reportState()

void reportState ( MultiQubit multiQubit )

Print the current state vector of probability amplitudes for a set of qubits to file.

File format:

real, imag
realComponent1, imagComponent1
realComponent2, imagComponent2
...
realComponentN, imagComponentN

File naming convention:

For each node that the program runs on, a file 'state_rank_[node_rank].csv' is generated. If there is more than one node, ranks after the first do not include the header

real, imag

so that files are easier to combine.

Parameters

[in,out] multiQubit object representing the set of qubits

Definition at line 62 of file QuEST.cpp.

References MultiQubit::chunkId, ComplexArray::imag, MultiQubit::numAmps, ComplexArray::real, and MultiQubit::stateVec.

                                        {
         FILE *state;
         char filename[100];
         long long int index;
         sprintf(filename, "state_rank_%d.csv", multiQubit.chunkId);
         state = fopen(filename, "w");
         if (multiQubit.chunkId==0) fprintf(state, "real, imag\n");
 
         for(index=0; index<multiQubit.numAmps; index++){
                 fprintf(state, "%.12f, %.12f\n", multiQubit.stateVec.real[index], multiQubit.stateVec.imag[index]);
         }
         fclose(state);
 }

◆ rotateAroundAxis()

void rotateAroundAxis	(	MultiQubit	multiQubit,
		const int	rotQubit,
		REAL	angle,
		Vector	unitAxis
	)

Rotate a single qubit by a given angle around a given vector on the Bloch-sphere.

The vector must not be zero (else an error is thrown), but needn't be unit magnitude.

Parameters

[in,out]	multiQubit	object representing the set of all qubits
[in]	rotQubit	qubit to rotate
[in]	angle	angle by which to rotate in radians
[in]	axis	vector around which to rotate

Exceptions

exitWithError if rotQubit is outside [0, multiQubit.numQubits), or if axis is the zero vector

Definition at line 91 of file QuEST.cpp.

References compactUnitary(), Complex::imag, Complex::real, Vector::x, Vector::y, and Vector::z.

Referenced by rotateX(), rotateY(), and rotateZ().

                                                                                          {
 
     double mag = sqrt(pow(axis.x,2) + pow(axis.y,2) + pow(axis.z,2));
     Vector unitAxis = {axis.x/mag, axis.y/mag, axis.z/mag};
 
     Complex alpha, beta;
     alpha.real = cos(angle/2.0);
     alpha.imag = -sin(angle/2.0)*unitAxis.z;    
     beta.real = sin(angle/2.0)*unitAxis.y;
     beta.imag = -sin(angle/2.0)*unitAxis.x;
     compactUnitary(multiQubit, rotQubit, alpha, beta);
 }

◆ rotateX()

void rotateX	(	MultiQubit	multiQubit,
		const int	rotQubit,
		REAL	angle
	)

Rotate a single qubit by a given angle around the X-axis of the Bloch-sphere.

For angle $\theta$ , applies

$\begin{pmatrix} \cos\theta/2 & -i \sin \theta/2\\ -i \sin \theta/2 & \cos \theta/2 \end{pmatrix}$

$\setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {rot}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_x(\theta)$}; \end{tikzpicture} }$

Parameters

[in,out]	multiQubit	object representing the set of all qubits
[in]	rotQubit	qubit to rotate
[in]	angle	angle by which to rotate in radians

Exceptions

exitWithError if rotQubit is outside [0, multiQubit.numQubits).

Definition at line 104 of file QuEST.cpp.

References rotateAroundAxis().

                                                                    {
 
     Vector unitAxis = {1, 0, 0};
     rotateAroundAxis(multiQubit, rotQubit, angle, unitAxis);
 }

◆ rotateY()

void rotateY	(	MultiQubit	multiQubit,
		const int	rotQubit,
		REAL	angle
	)

Rotate a single qubit by a given angle around the Y-axis of the Bloch-sphere.

For angle $\theta$ , applies

$\begin{pmatrix} \cos\theta/2 & \sin \theta/2\\ \sin \theta/2 & \cos \theta/2 \end{pmatrix}$

$\setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {rot}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_y(\theta)$}; \end{tikzpicture} }$

Parameters

[in,out]	multiQubit	object representing the set of all qubits
[in]	rotQubit	qubit to rotate
[in]	angle	angle by which to rotate in radians

Exceptions

exitWithError if rotQubit is outside [0, multiQubit.numQubits).

Definition at line 110 of file QuEST.cpp.

References rotateAroundAxis().

                                                                    {
 
     Vector unitAxis = {0, 1, 0};
     rotateAroundAxis(multiQubit, rotQubit, angle, unitAxis);
 }

◆ rotateZ()

void rotateZ	(	MultiQubit	multiQubit,
		const int	rotQubit,
		REAL	angle
	)

Rotate a single qubit by a given angle around the Z-axis of the Bloch-sphere (also known as a phase shift gate).

For angle $\theta$ , applies

$\begin{pmatrix} \exp(-i \theta/2) & 0 \\ 0 & \exp(i \theta/2) \end{pmatrix}$

$\setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {rot}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$R_z(\theta)$}; \end{tikzpicture} }$

Parameters

[in,out]	multiQubit	object representing the set of all qubits
[in]	rotQubit	qubit to rotate
[in]	angle	angle by which to rotate in radians

Exceptions

exitWithError if rotQubit is outside [0, multiQubit.numQubits).

Definition at line 116 of file QuEST.cpp.

References rotateAroundAxis().

                                                                    {
 
     Vector unitAxis = {0, 0, 1};
     rotateAroundAxis(multiQubit, rotQubit, angle, unitAxis);
 }

◆ sGate()

void sGate	(	MultiQubit	multiQubit,
		const int	targetQubit
	)

Apply the single-qubit S gate.

This is a rotation of $\pi/2$ around the Z-axis on the Bloch sphere, or the unitary:

$\begin{pmatrix} 1 & 0 \\ 0 & i \end{pmatrix}$

$\setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {S}; \end{tikzpicture} }$

Parameters

[in,out]	multiQubit	object representing the set of all qubits
[in]	targetQubit	qubit to operate upon

Exceptions

exitWithError if targetQubit is outside [0, multiQubit.numQubits)

Definition at line 158 of file QuEST.cpp.

References phaseGate(), and S_GATE.

 {
     phaseGate(multiQubit, targetQubit, S_GATE);
 } 

◆ sigmaZ()

void sigmaZ	(	MultiQubit	multiQubit,
		const int	targetQubit
	)

Apply the single-qubit sigma-Z (also known as the Z, Pauli-Z or phase-flip) gate.

This is a rotation of $\pi$ around the Z-axis (a phase shift) on the Bloch sphere. I.e.

$\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$

$\setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {$\sigma_z$}; \end{tikzpicture} }$

Parameters

[in,out]	multiQubit	object representing the set of all qubits
[in]	targetQubit	qubit to operate on

Exceptions

exitWithError if targetQubit is outside [0, multiQubit.numQubits).

Definition at line 153 of file QuEST.cpp.

References phaseGate(), and SIGMA_Z.

 {
     phaseGate(multiQubit, targetQubit, SIGMA_Z);
 }

◆ tGate()

void tGate	(	MultiQubit	multiQubit,
		const int	targetQubit
	)

Apply the single-qubit T gate.

This is a rotation of $\pi/4$ around the Z-axis on the Bloch sphere, or the unitary:

$\begin{pmatrix} 1 & 0 \\ 0 & \exp\left(i \frac{\pi}{4}\right) \end{pmatrix}$

$\setlength{\fboxrule}{0.01pt} \fbox{ \begin{tikzpicture}[scale=.5] \node[draw=none] at (-3.5, 0) {target}; \draw (-2,0) -- (-1, 0); \draw (1, 0) -- (2, 0); \draw (-1,-1)--(-1,1)--(1,1)--(1,-1)--cycle; \node[draw=none] at (0, 0) {T}; \end{tikzpicture} }$

Parameters

[in,out]	multiQubit	object representing the set of all qubits
[in]	targetQubit	qubit to operate upon

Exceptions

exitWithError if targetQubit is outside [0, multiQubit.numQubits)

Definition at line 163 of file QuEST.cpp.

References phaseGate(), and T_GATE.

 {
     phaseGate(multiQubit, targetQubit, T_GATE);
 }

◆ validateAlphaBeta()

int validateAlphaBeta	(	Complex	alpha,
		Complex	beta
	)

Definition at line 193 of file QuEST.cpp.

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

                                                   {
     if ( fabs(alpha.real*alpha.real 
         + alpha.imag*alpha.imag
         + beta.real*beta.real 
         + beta.imag*beta.imag - 1) > REAL_EPS ) return 0;
     else return 1;
 }

◆ validateMatrixIsUnitary()

int validateMatrixIsUnitary ( ComplexMatrix2 u )

Definition at line 168 of file QuEST.cpp.

References Complex::imag, ComplexMatrix2::r0c0, ComplexMatrix2::r0c1, ComplexMatrix2::r1c0, ComplexMatrix2::r1c1, Complex::real, and REAL_EPS.

                                              {
 
     if ( fabs(u.r0c0.real*u.r0c0.real 
         + u.r0c0.imag*u.r0c0.imag
         + u.r1c0.real*u.r1c0.real
         + u.r1c0.imag*u.r1c0.imag - 1) > REAL_EPS ) return 0;
     // check
     if ( fabs(u.r0c1.real*u.r0c1.real 
         + u.r0c1.imag*u.r0c1.imag
         + u.r1c1.real*u.r1c1.real
         + u.r1c1.imag*u.r1c1.imag - 1) > REAL_EPS ) return 0;
 
     if ( fabs(u.r0c0.real*u.r0c1.real 
         + u.r0c0.imag*u.r0c1.imag
         + u.r1c0.real*u.r1c1.real
         + u.r1c0.imag*u.r1c1.imag) > REAL_EPS ) return 0;
 
     if ( fabs(u.r0c1.real*u.r0c0.imag
         - u.r0c0.real*u.r0c1.imag
         + u.r1c1.real*u.r1c0.imag
         - u.r1c0.real*u.r1c1.imag) > REAL_EPS ) return 0;
 
     return 1;
 }

◆ validateUnitVector()

int validateUnitVector	(	REAL	ux,
		REAL	uy,
		REAL	uz
	)

Definition at line 201 of file QuEST.cpp.

References REAL_EPS.

                                                  {
     if ( fabs(sqrt(ux*ux + uy*uy + uz*uz) - 1) > REAL_EPS ) return 0;
     else return 1;
 }

Variable Documentation

◆ errorCodes

const char* errorCodes[]

Initial value:

= {
    "Success",                                              
    "Invalid target qubit. Note qubits are zero indexed.",  
    "Invalid control qubit. Note qubits are zero indexed.", 
    "Control qubit cannot equal target qubit.",             
    "Invalid number of control qubits",                     
    "Invalid unitary matrix.",                              
    "Invalid rotation arguments.",                          
    "Invalid system size. Cannot print output for systems greater than 5 qubits.", 
    "Can't collapse to state with zero probability.", 
    "Invalid number of qubits.", 
    "Invalid measurement outcome -- must be either 0 or 1." 
}

Definition at line 24 of file QuEST.cpp.

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ DEBUG

Function Documentation

◆ controlledRotateAroundAxis()

◆ controlledRotateX()

◆ controlledRotateY()

◆ controlledRotateZ()

◆ hashString()

◆ QuESTSeedRandom()

◆ QuESTSeedRandomDefault()

◆ reportMultiQubitParams()

◆ reportState()

◆ rotateAroundAxis()

◆ rotateX()

◆ rotateY()

◆ rotateZ()

◆ sGate()

◆ sigmaZ()

◆ tGate()

◆ validateAlphaBeta()

◆ validateMatrixIsUnitary()

◆ validateUnitVector()

Variable Documentation

◆ errorCodes