Macros | Functions
QuEST_common.c File Reference
#include "QuEST.h"
#include "QuEST_internal.h"
#include "QuEST_precision.h"
#include "QuEST_validation.h"
#include "mt19937ar.h"
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>

Go to the source code of this file.

Macros

#define macro_allocStackComplexMatrixN(matrix, numQubits)
 
#define macro_initialiseStackComplexMatrixN(matrix, numQubits, real, imag)
 
#define macro_populateKrausOperator(superOp, ops, numOps, opDim)
 
#define macro_setConjugateMatrix(dest, src, dim)
 

Functions

ComplexMatrixN bindArraysToStackComplexMatrixN (int numQubits, qreal re[][1<< numQubits], qreal im[][1<< numQubits], qreal **reStorage, qreal **imStorage)
 
void densmatr_applyKrausSuperoperator (Qureg qureg, int target, ComplexMatrix4 superOp)
 
void densmatr_applyMultiQubitKrausSuperoperator (Qureg qureg, int *targets, int numTargets, ComplexMatrixN superOp)
 
void densmatr_applyTwoQubitKrausSuperoperator (Qureg qureg, int target1, int target2, ComplexMatrixN superOp)
 
int densmatr_measureWithStats (Qureg qureg, int measureQubit, qreal *outcomeProb)
 
void densmatr_mixKrausMap (Qureg qureg, int target, ComplexMatrix2 *ops, int numOps)
 
void densmatr_mixMultiQubitKrausMap (Qureg qureg, int *targets, int numTargets, ComplexMatrixN *ops, int numOps)
 
void densmatr_mixPauli (Qureg qureg, int qubit, qreal probX, qreal probY, qreal probZ)
 
void densmatr_mixTwoQubitKrausMap (Qureg qureg, int target1, int target2, ComplexMatrix4 *ops, int numOps)
 
void ensureIndsIncrease (int *ind1, int *ind2)
 
int generateMeasurementOutcome (qreal zeroProb, qreal *outcomeProb)
 
void getComplexPairAndPhaseFromUnitary (ComplexMatrix2 u, Complex *alpha, Complex *beta, qreal *globalPhase)
 maps U(r0c0, r0c1, r1c0, r1c1) to exp(i globalPhase) U(alpha, beta) More...
 
void getComplexPairFromRotation (qreal angle, Vector axis, Complex *alpha, Complex *beta)
 
ComplexMatrix2 getConjugateMatrix2 (ComplexMatrix2 src)
 
ComplexMatrix4 getConjugateMatrix4 (ComplexMatrix4 src)
 
Complex getConjugateScalar (Complex scalar)
 
long long int getControlFlipMask (int *controlQubits, int *controlState, const int numControlQubits)
 
long long int getQubitBitMask (int *qubits, const int numQubits)
 
void getQuESTDefaultSeedKey (unsigned long int *key)
 
Vector getUnitVector (Vector vec)
 
qreal getVectorMagnitude (Vector vec)
 
void getZYZRotAnglesFromComplexPair (Complex alpha, Complex beta, qreal *rz2, qreal *ry, qreal *rz1)
 maps U(alpha, beta) to Rz(rz2) Ry(ry) Rz(rz1) More...
 
unsigned long int hashString (char *str)
 
void populateKrausSuperOperator2 (ComplexMatrix4 *superOp, ComplexMatrix2 *ops, int numOps)
 
void populateKrausSuperOperator4 (ComplexMatrixN *superOp, ComplexMatrix4 *ops, int numOps)
 
void populateKrausSuperOperatorN (ComplexMatrixN *superOp, ComplexMatrixN *ops, int numOps)
 
void reportQuregParams (Qureg qureg)
 Report metainformation about a set of qubits: number of qubits, number of probability amplitudes. More...
 
void reportState (Qureg qureg)
 Print the current state vector of probability amplitudes for a set of qubits to file. More...
 
void seedQuEST (unsigned long int *seedArray, int numSeeds)
 numSeeds <= 64 More...
 
void setConjugateMatrixN (ComplexMatrixN m)
 
void shiftIndices (int *indices, int numIndices, int shift)
 
void statevec_applyPauliProd (Qureg workspace, int *targetQubits, enum pauliOpType *pauliCodes, int numTargets)
 
void statevec_applyPauliSum (Qureg inQureg, enum pauliOpType *allCodes, qreal *termCoeffs, int numSumTerms, Qureg outQureg)
 
qreal statevec_calcExpecPauliProd (Qureg qureg, int *targetQubits, enum pauliOpType *pauliCodes, int numTargets, Qureg workspace)
 
qreal statevec_calcExpecPauliSum (Qureg qureg, enum pauliOpType *allCodes, qreal *termCoeffs, int numSumTerms, Qureg workspace)
 
qreal statevec_calcFidelity (Qureg qureg, Qureg pureState)
 
void statevec_controlledMultiQubitUnitary (Qureg qureg, int ctrl, int *targets, const int numTargets, ComplexMatrixN u)
 
void statevec_controlledRotateAroundAxis (Qureg qureg, const int controlQubit, const int targetQubit, qreal angle, Vector axis)
 
void statevec_controlledRotateAroundAxisConj (Qureg qureg, const int controlQubit, const int targetQubit, qreal angle, Vector axis)
 
void statevec_controlledRotateX (Qureg qureg, const int controlQubit, const int targetQubit, qreal angle)
 
void statevec_controlledRotateY (Qureg qureg, const int controlQubit, const int targetQubit, qreal angle)
 
void statevec_controlledRotateZ (Qureg qureg, const int controlQubit, const int targetQubit, qreal angle)
 
void statevec_controlledTwoQubitUnitary (Qureg qureg, const int controlQubit, const int targetQubit1, const int targetQubit2, ComplexMatrix4 u)
 
qreal statevec_getProbAmp (Qureg qureg, long long int index)
 
int statevec_measureWithStats (Qureg qureg, int measureQubit, qreal *outcomeProb)
 
void statevec_multiQubitUnitary (Qureg qureg, int *targets, const int numTargets, ComplexMatrixN u)
 
void statevec_multiRotatePauli (Qureg qureg, int *targetQubits, enum pauliOpType *targetPaulis, int numTargets, qreal angle, int applyConj)
 applyConj=1 will apply conjugate operation, else applyConj=0 More...
 
void statevec_pauliZ (Qureg qureg, const int targetQubit)
 
void statevec_phaseShift (Qureg qureg, const int targetQubit, qreal angle)
 
void statevec_rotateAroundAxis (Qureg qureg, const int rotQubit, qreal angle, Vector axis)
 
void statevec_rotateAroundAxisConj (Qureg qureg, const int rotQubit, qreal angle, Vector axis)
 
void statevec_rotateX (Qureg qureg, const int rotQubit, qreal angle)
 
void statevec_rotateY (Qureg qureg, const int rotQubit, qreal angle)
 
void statevec_rotateZ (Qureg qureg, const int rotQubit, qreal angle)
 
void statevec_sGate (Qureg qureg, const int targetQubit)
 
void statevec_sGateConj (Qureg qureg, const int targetQubit)
 
void statevec_sqrtSwapGate (Qureg qureg, int qb1, int qb2)
 
void statevec_sqrtSwapGateConj (Qureg qureg, int qb1, int qb2)
 
void statevec_tGate (Qureg qureg, const int targetQubit)
 
void statevec_tGateConj (Qureg qureg, const int targetQubit)
 
void statevec_twoQubitUnitary (Qureg qureg, const int targetQubit1, const int targetQubit2, ComplexMatrix4 u)
 

Detailed Description

Internal and API functions which are hardware-agnostic. These must never call a front-end function in QuEST.c, which would lead to duplication of e.g. QASM logging and validation. Note that though many of these functions are prefixed with statevec_, they will be called multiple times to effect their equivalent operation on density matrices, so the passed Qureg can be assumed a statevector. Functions prefixed with densmatr_ may still explicitly call statevec_ functions, but will need to manually apply the conjugate qubit-shifted operations to satisfy the Choi–Jamiolkowski isomorphism

Author
Tyson Jones
Ania Brown (seeding, reporting)
Balint Koczor (Kraus maps, mixPauli, Windows compatibility)

Definition in file QuEST_common.c.

Macro Definition Documentation

◆ macro_allocStackComplexMatrixN

#define macro_allocStackComplexMatrixN (   matrix,
  numQubits 
)
Value:
/* reArr_, imArr_, reStorage_, and imStorage_ must not exist in calling scope */ \
qreal reArr_[1<<(numQubits)][1<<(numQubits)]; \
qreal imArr_[1<<(numQubits)][1<<(numQubits)]; \
macro_initialiseStackComplexMatrixN(matrix, (numQubits), reArr_, imArr_);

Definition at line 628 of file QuEST_common.c.

◆ macro_initialiseStackComplexMatrixN

#define macro_initialiseStackComplexMatrixN (   matrix,
  numQubits,
  real,
  imag 
)
Value:
/* reStorage_ and imStorage_ must not exist in calling scope */ \
qreal* reStorage_[1<<(numQubits)]; \
qreal* imStorage_[1<<(numQubits)]; \
matrix = bindArraysToStackComplexMatrixN((numQubits), real, imag, reStorage_, imStorage_);

Definition at line 622 of file QuEST_common.c.

◆ macro_populateKrausOperator

#define macro_populateKrausOperator (   superOp,
  ops,
  numOps,
  opDim 
)
Value:
/* clear the superop */ \
for (int r=0; r < (opDim)*(opDim); r++) \
for (int c=0; c < (opDim)*(opDim); c++) { \
superOp->real[r][c] = 0; \
superOp->imag[r][c] = 0; \
} \
/* add each op's contribution to the superop */ \
for (int n=0; n<(numOps); n++) \
/* superop += conjugate(op) (x) op, where (x) is a tensor product */ \
for (int i = 0; i < (opDim); i++) \
for (int j = 0; j < (opDim); j++) \
for (int k = 0; k < (opDim); k++) \
for (int l = 0; l < (opDim); l++) { \
superOp->real[i*(opDim) + k][j*(opDim) + l] += \
ops[n].real[i][j]*ops[n].real[k][l] + \
ops[n].imag[i][j]*ops[n].imag[k][l]; \
superOp->imag[i*(opDim) + k][j*(opDim) + l] += \
ops[n].real[i][j]*ops[n].imag[k][l] - \
ops[n].imag[i][j]*ops[n].real[k][l]; \
}

Definition at line 540 of file QuEST_common.c.

◆ macro_setConjugateMatrix

#define macro_setConjugateMatrix (   dest,
  src,
  dim 
)
Value:
for (int i=0; i<dim; i++) \
for (int j=0; j<dim; j++) { \
dest.real[i][j] = src.real[i][j]; \
dest.imag[i][j] = - src.imag[i][j]; /* negative for conjugate */ \
}

Definition at line 92 of file QuEST_common.c.

Function Documentation

◆ bindArraysToStackComplexMatrixN()

ComplexMatrixN bindArraysToStackComplexMatrixN ( int  numQubits,
qreal  re[][1<< numQubits],
qreal  im[][1<< numQubits],
qreal **  reStorage,
qreal **  imStorage 
)

Definition at line 606 of file QuEST_common.c.

609  {
610  ComplexMatrixN m;
611  m.numQubits = numQubits;
612  m.real = reStorage;
613  m.imag = imStorage;
614 
615  int len = 1<<numQubits;
616  for (int i=0; i<len; i++) {
617  m.real[i] = re[i];
618  m.imag[i] = im[i];
619  }
620  return m;
621 }

References ComplexMatrixN::imag, ComplexMatrixN::numQubits, and ComplexMatrixN::real.

◆ densmatr_applyKrausSuperoperator()

void densmatr_applyKrausSuperoperator ( Qureg  qureg,
int  target,
ComplexMatrix4  superOp 
)

Definition at line 575 of file QuEST_common.c.

575  {
576 
577  long long int ctrlMask = 0;
578  statevec_multiControlledTwoQubitUnitary(qureg, ctrlMask, target, target + qureg.numQubitsRepresented, superOp);
579 }

References Qureg::numQubitsRepresented, and statevec_multiControlledTwoQubitUnitary().

Referenced by densmatr_mixKrausMap().

◆ densmatr_applyMultiQubitKrausSuperoperator()

void densmatr_applyMultiQubitKrausSuperoperator ( Qureg  qureg,
int *  targets,
int  numTargets,
ComplexMatrixN  superOp 
)

Definition at line 589 of file QuEST_common.c.

589  {
590  long long int ctrlMask = 0;
591  int allTargets[2*numTargets];
592  for (int t=0; t < numTargets; t++) {
593  allTargets[t] = targets[t];
594  allTargets[t+numTargets] = targets[t] + qureg.numQubitsRepresented;
595  }
596  statevec_multiControlledMultiQubitUnitary(qureg, ctrlMask, allTargets, 2*numTargets, superOp);
597 }

References Qureg::numQubitsRepresented, and statevec_multiControlledMultiQubitUnitary().

Referenced by densmatr_mixMultiQubitKrausMap().

◆ densmatr_applyTwoQubitKrausSuperoperator()

void densmatr_applyTwoQubitKrausSuperoperator ( Qureg  qureg,
int  target1,
int  target2,
ComplexMatrixN  superOp 
)

Definition at line 581 of file QuEST_common.c.

581  {
582 
583  long long int ctrlMask = 0;
584  int numQb = qureg.numQubitsRepresented;
585  int allTargets[4] = {target1, target2, target1+numQb, target2+numQb};
586  statevec_multiControlledMultiQubitUnitary(qureg, ctrlMask, allTargets, 4, superOp);
587 }

References Qureg::numQubitsRepresented, and statevec_multiControlledMultiQubitUnitary().

Referenced by densmatr_mixTwoQubitKrausMap().

◆ densmatr_measureWithStats()

int densmatr_measureWithStats ( Qureg  qureg,
int  measureQubit,
qreal *  outcomeProb 
)

Definition at line 368 of file QuEST_common.c.

368  {
369 
370  qreal zeroProb = densmatr_calcProbOfOutcome(qureg, measureQubit, 0);
371  int outcome = generateMeasurementOutcome(zeroProb, outcomeProb);
372  densmatr_collapseToKnownProbOutcome(qureg, measureQubit, outcome, *outcomeProb);
373  return outcome;
374 }

References densmatr_calcProbOfOutcome(), densmatr_collapseToKnownProbOutcome(), generateMeasurementOutcome(), and qreal.

Referenced by measure(), and measureWithStats().

◆ densmatr_mixKrausMap()

void densmatr_mixKrausMap ( Qureg  qureg,
int  target,
ComplexMatrix2 *  ops,
int  numOps 
)

Definition at line 599 of file QuEST_common.c.

599  {
600 
601  ComplexMatrix4 superOp;
602  populateKrausSuperOperator2(&superOp, ops, numOps);
603  densmatr_applyKrausSuperoperator(qureg, target, superOp);
604 }

References densmatr_applyKrausSuperoperator(), and populateKrausSuperOperator2().

Referenced by densmatr_mixPauli(), and mixKrausMap().

◆ densmatr_mixMultiQubitKrausMap()

void densmatr_mixMultiQubitKrausMap ( Qureg  qureg,
int *  targets,
int  numTargets,
ComplexMatrixN *  ops,
int  numOps 
)

Definition at line 642 of file QuEST_common.c.

642  {
643 
644  ComplexMatrixN superOp;
645 
646  /* superOp will contain 2^(4 numTargets) complex numbers.
647  * At double precision, superOp will cost additional memory:
648  * numTargs=1 -> 0.25 KiB
649  * numTargs=2 -> 4 KiB
650  * numTargs=3 -> 64 KiB
651  * numTargs=4 -> 1 MiB
652  * numTargs=5 -> 16 MiB.
653  * At quad precision (usually 10 B per number, but possibly 16 B due to alignment),
654  * this costs at most double.
655  *
656  * Hence, if superOp is kept in the stack, numTargs >= 4 would exceed Windows' 1 MB
657  * maximum stack-space allocation (numTargs >= 5 exceeding Linux' 8 MB). Therefore,
658  * for numTargets < 4, superOp will be kept in the stack, else in the heap
659  */
660 
661  if (numTargets < 4) {
662  // everything must live in 'if' since this macro declares local vars
663  macro_allocStackComplexMatrixN(superOp, 2*numTargets);
664  populateKrausSuperOperatorN(&superOp, ops, numOps);
665  densmatr_applyMultiQubitKrausSuperoperator(qureg, targets, numTargets, superOp);
666  }
667  else {
668  superOp = createComplexMatrixN(2*numTargets);
669  populateKrausSuperOperatorN(&superOp, ops, numOps);
670  densmatr_applyMultiQubitKrausSuperoperator(qureg, targets, numTargets, superOp);
671  destroyComplexMatrixN(superOp);
672  }
673 }

References createComplexMatrixN(), densmatr_applyMultiQubitKrausSuperoperator(), destroyComplexMatrixN(), macro_allocStackComplexMatrixN, and populateKrausSuperOperatorN().

Referenced by mixMultiQubitKrausMap().

◆ densmatr_mixPauli()

void densmatr_mixPauli ( Qureg  qureg,
int  qubit,
qreal  probX,
qreal  probY,
qreal  probZ 
)

Definition at line 675 of file QuEST_common.c.

675  {
676 
677  // convert pauli probabilities into Kraus map
678  const int numOps = 4;
679  ComplexMatrix2 ops[numOps];
680  for (int n=0; n < numOps; n++)
681  ops[n] = (ComplexMatrix2) {.real={{0}}, .imag={{0}}};
682 
683  qreal facs[4] = { // literal numOps=4 for valid initialisation
684  sqrt(1-(probX + probY + probZ)),
685  sqrt(probX),
686  sqrt(probY),
687  sqrt(probZ)
688  };
689  ops[0].real[0][0] = facs[0]; ops[0].real[1][1] = facs[0];
690  ops[1].real[0][1] = facs[1]; ops[1].real[1][0] = facs[1];
691  ops[2].imag[0][1] = -facs[2]; ops[2].imag[1][0] = facs[2];
692  ops[3].real[0][0] = facs[3]; ops[3].real[1][1] = -facs[3];
693 
694  densmatr_mixKrausMap(qureg, qubit, ops, numOps);
695 }

References densmatr_mixKrausMap(), ComplexMatrix2::imag, qreal, and ComplexMatrix2::real.

Referenced by mixPauli().

◆ densmatr_mixTwoQubitKrausMap()

void densmatr_mixTwoQubitKrausMap ( Qureg  qureg,
int  target1,
int  target2,
ComplexMatrix4 *  ops,
int  numOps 
)

Definition at line 634 of file QuEST_common.c.

634  {
635 
636  ComplexMatrixN superOp;
637  macro_allocStackComplexMatrixN(superOp, 4);
638  populateKrausSuperOperator4(&superOp, ops, numOps);
639  densmatr_applyTwoQubitKrausSuperoperator(qureg, target1, target2, superOp);
640 }

References densmatr_applyTwoQubitKrausSuperoperator(), macro_allocStackComplexMatrixN, and populateKrausSuperOperator4().

Referenced by mixTwoQubitKrausMap().

◆ ensureIndsIncrease()

void ensureIndsIncrease ( int *  ind1,
int *  ind2 
)

Definition at line 63 of file QuEST_common.c.

63  {
64 
65  if (*ind1 > *ind2) {
66  int copy = *ind1;
67  *ind1 = *ind2;
68  *ind2 = copy;
69  }
70 }

Referenced by mixTwoQubitDephasing(), and mixTwoQubitDepolarising().

◆ generateMeasurementOutcome()

int generateMeasurementOutcome ( qreal  zeroProb,
qreal *  outcomeProb 
)

Definition at line 154 of file QuEST_common.c.

154  {
155 
156  // randomly choose outcome
157  int outcome;
158  if (zeroProb < REAL_EPS)
159  outcome = 1;
160  else if (1-zeroProb < REAL_EPS)
161  outcome = 0;
162  else
163  outcome = (genrand_real1() > zeroProb);
164 
165  // set probability of outcome
166  *outcomeProb = (outcome==0)? zeroProb : 1-zeroProb;
167 
168  return outcome;
169 }

References genrand_real1().

Referenced by densmatr_measureWithStats(), and statevec_measureWithStats().

◆ getComplexPairAndPhaseFromUnitary()

void getComplexPairAndPhaseFromUnitary ( ComplexMatrix2  u,
Complex *  alpha,
Complex *  beta,
qreal *  globalPhase 
)

maps U(r0c0, r0c1, r1c0, r1c1) to exp(i globalPhase) U(alpha, beta)

Definition at line 135 of file QuEST_common.c.

135  {
136 
137  qreal r0c0Phase = atan2(u.imag[0][0], u.real[0][0]);
138  qreal r1c1Phase = atan2(u.imag[1][1], u.real[1][1]);
139  *globalPhase = (r0c0Phase + r1c1Phase)/2.0;
140 
141  qreal cosPhase = cos(*globalPhase);
142  qreal sinPhase = sin(*globalPhase);
143  alpha->real = u.real[0][0]*cosPhase + u.imag[0][0]*sinPhase;
144  alpha->imag = u.imag[0][0]*cosPhase - u.real[0][0]*sinPhase;
145  beta->real = u.real[1][0]*cosPhase + u.imag[1][0]*sinPhase;
146  beta->imag = u.imag[1][0]*cosPhase - u.real[1][0]*sinPhase;
147 }

References Complex::imag, ComplexMatrix2::imag, qreal, Complex::real, and ComplexMatrix2::real.

Referenced by qasm_recordControlledUnitary(), qasm_recordMultiControlledUnitary(), and qasm_recordUnitary().

◆ getComplexPairFromRotation()

void getComplexPairFromRotation ( qreal  angle,
Vector  axis,
Complex *  alpha,
Complex *  beta 
)

Definition at line 113 of file QuEST_common.c.

113  {
114 
115  Vector unitAxis = getUnitVector(axis);
116  alpha->real = cos(angle/2.0);
117  alpha->imag = - sin(angle/2.0)*unitAxis.z;
118  beta->real = sin(angle/2.0)*unitAxis.y;
119  beta->imag = - sin(angle/2.0)*unitAxis.x;
120 }

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

Referenced by qasm_recordAxisRotation(), qasm_recordControlledAxisRotation(), statevec_controlledRotateAroundAxis(), statevec_controlledRotateAroundAxisConj(), statevec_rotateAroundAxis(), and statevec_rotateAroundAxisConj().

◆ getConjugateMatrix2()

ComplexMatrix2 getConjugateMatrix2 ( ComplexMatrix2  src)

Definition at line 98 of file QuEST_common.c.

98  {
99  ComplexMatrix2 conj;
100  macro_setConjugateMatrix(conj, src, 2);
101  return conj;
102 }

References macro_setConjugateMatrix.

Referenced by controlledUnitary(), multiControlledUnitary(), multiStateControlledUnitary(), and unitary().

◆ getConjugateMatrix4()

ComplexMatrix4 getConjugateMatrix4 ( ComplexMatrix4  src)

Definition at line 103 of file QuEST_common.c.

103  {
104  ComplexMatrix4 conj;
105  macro_setConjugateMatrix(conj, src, 4);
106  return conj;
107 }

References macro_setConjugateMatrix.

Referenced by controlledTwoQubitUnitary(), multiControlledTwoQubitUnitary(), and twoQubitUnitary().

◆ getConjugateScalar()

Complex getConjugateScalar ( Complex  scalar)

Definition at line 84 of file QuEST_common.c.

84  {
85 
86  Complex conjScalar;
87  conjScalar.real = scalar.real;
88  conjScalar.imag = - scalar.imag;
89  return conjScalar;
90 }

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

Referenced by compactUnitary(), and controlledCompactUnitary().

◆ getControlFlipMask()

long long int getControlFlipMask ( int *  controlQubits,
int *  controlState,
const int  numControlQubits 
)

Definition at line 53 of file QuEST_common.c.

53  {
54 
55  long long int mask=0;
56  for (int i=0; i<numControlQubits; i++)
57  if (controlState[i] == 0)
58  mask = mask | (1LL << controlQubits[i]);
59 
60  return mask;
61 }

Referenced by multiStateControlledUnitary().

◆ getQubitBitMask()

long long int getQubitBitMask ( int *  qubits,
const int  numQubits 
)

Definition at line 43 of file QuEST_common.c.

43  {
44 
45  long long int mask=0;
46  for (int i=0; i<numQubits; i++)
47  mask = mask | (1LL << qubits[i]);
48 
49  return mask;
50 }

Referenced by multiControlledMultiQubitUnitary(), multiControlledTwoQubitUnitary(), multiControlledUnitary(), multiRotateZ(), multiStateControlledUnitary(), statevec_multiControlledMultiQubitUnitary(), statevec_multiControlledPhaseFlip(), statevec_multiControlledPhaseShift(), statevec_multiRotatePauli(), and validateMultiControlsMultiTargets().

◆ getQuESTDefaultSeedKey()

void getQuESTDefaultSeedKey ( unsigned long int *  key)

Definition at line 181 of file QuEST_common.c.

181  {
182  // init MT random number generator with two keys -- time and pid
183  // for the MPI version, it is ok that all procs will get the same seed as random numbers will only be
184  // used by the master process
185 #if defined(_WIN32) && ! defined(__MINGW32__)
186 
187  unsigned long int pid = (unsigned long int) _getpid();
188  unsigned long int msecs = (unsigned long int) GetTickCount64();
189 
190  key[0] = msecs; key[1] = pid;
191 #else
192  struct timeval tv;
193  gettimeofday(&tv, NULL);
194 
195  double time_in_mill =
196  (tv.tv_sec) * 1000 + (tv.tv_usec) / 1000 ; // convert tv_sec & tv_usec to millisecond
197 
198  unsigned long int pid = getpid();
199  unsigned long int msecs = (unsigned long int) time_in_mill;
200 
201  key[0] = msecs; key[1] = pid;
202 #endif
203 }

Referenced by seedQuESTDefault().

◆ getUnitVector()

Vector getUnitVector ( Vector  vec)

Definition at line 77 of file QuEST_common.c.

77  {
78 
79  qreal mag = getVectorMagnitude(vec);
80  Vector unitVec = (Vector) {.x=vec.x/mag, .y=vec.y/mag, .z=vec.z/mag};
81  return unitVec;
82 }

References getVectorMagnitude(), qreal, Vector::x, Vector::y, and Vector::z.

Referenced by getComplexPairFromRotation().

◆ getVectorMagnitude()

qreal getVectorMagnitude ( Vector  vec)

Definition at line 72 of file QuEST_common.c.

72  {
73 
74  return sqrt(vec.x*vec.x + vec.y*vec.y + vec.z*vec.z);
75 }

References Vector::x, Vector::y, and Vector::z.

Referenced by getUnitVector(), and validateVector().

◆ getZYZRotAnglesFromComplexPair()

void getZYZRotAnglesFromComplexPair ( Complex  alpha,
Complex  beta,
qreal *  rz2,
qreal *  ry,
qreal *  rz1 
)

maps U(alpha, beta) to Rz(rz2) Ry(ry) Rz(rz1)

Definition at line 123 of file QuEST_common.c.

123  {
124 
125  qreal alphaMag = sqrt(alpha.real*alpha.real + alpha.imag*alpha.imag);
126  *ry = 2.0 * acos(alphaMag);
127 
128  qreal alphaPhase = atan2(alpha.imag, alpha.real);
129  qreal betaPhase = atan2(beta.imag, beta.real);
130  *rz2 = - alphaPhase + betaPhase;
131  *rz1 = - alphaPhase - betaPhase;
132 }

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

Referenced by qasm_recordAxisRotation(), qasm_recordCompactUnitary(), qasm_recordControlledAxisRotation(), qasm_recordControlledCompactUnitary(), qasm_recordControlledUnitary(), qasm_recordMultiControlledUnitary(), and qasm_recordUnitary().

◆ hashString()

unsigned long int hashString ( char *  str)

Definition at line 171 of file QuEST_common.c.

171  {
172  unsigned long int hash = 5381;
173  int c;
174 
175  while ((c = *str++))
176  hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
177 
178  return hash;
179 }

◆ populateKrausSuperOperator2()

void populateKrausSuperOperator2 ( ComplexMatrix4 *  superOp,
ComplexMatrix2 *  ops,
int  numOps 
)

Definition at line 562 of file QuEST_common.c.

562  {
563  int opDim = 2;
564  macro_populateKrausOperator(superOp, ops, numOps, opDim);
565 }

References macro_populateKrausOperator.

Referenced by densmatr_mixKrausMap().

◆ populateKrausSuperOperator4()

void populateKrausSuperOperator4 ( ComplexMatrixN *  superOp,
ComplexMatrix4 *  ops,
int  numOps 
)

Definition at line 566 of file QuEST_common.c.

566  {
567  int opDim = 4;
568  macro_populateKrausOperator(superOp, ops, numOps, opDim);
569 }

References macro_populateKrausOperator.

Referenced by densmatr_mixTwoQubitKrausMap().

◆ populateKrausSuperOperatorN()

void populateKrausSuperOperatorN ( ComplexMatrixN *  superOp,
ComplexMatrixN *  ops,
int  numOps 
)

Definition at line 570 of file QuEST_common.c.

570  {
571  int opDim = 1 << ops[0].numQubits;
572  macro_populateKrausOperator(superOp, ops, numOps, opDim);
573 }

References macro_populateKrausOperator, and ComplexMatrixN::numQubits.

Referenced by densmatr_mixMultiQubitKrausMap().

◆ setConjugateMatrixN()

void setConjugateMatrixN ( ComplexMatrixN  m)

Definition at line 108 of file QuEST_common.c.

108  {
109  int len = 1 << m.numQubits;
110  macro_setConjugateMatrix(m, m, len);
111 }

References macro_setConjugateMatrix, and ComplexMatrixN::numQubits.

Referenced by controlledMultiQubitUnitary(), multiControlledMultiQubitUnitary(), and multiQubitUnitary().

◆ shiftIndices()

void shiftIndices ( int *  indices,
int  numIndices,
int  shift 
)

Definition at line 149 of file QuEST_common.c.

149  {
150  for (int j=0; j < numIndices; j++)
151  indices[j] += shift;
152 }

Referenced by controlledMultiQubitUnitary(), multiControlledMultiQubitUnitary(), multiControlledPhaseFlip(), multiControlledPhaseShift(), multiQubitUnitary(), and multiRotatePauli().

◆ statevec_applyPauliProd()

void statevec_applyPauliProd ( Qureg  workspace,
int *  targetQubits,
enum pauliOpType *  pauliCodes,
int  numTargets 
)

Definition at line 450 of file QuEST_common.c.

450  {
451 
452  for (int i=0; i < numTargets; i++) {
453  // (pauliCodes[i] == PAULI_I) applies no operation
454  if (pauliCodes[i] == PAULI_X)
455  statevec_pauliX(workspace, targetQubits[i]);
456  if (pauliCodes[i] == PAULI_Y)
457  statevec_pauliY(workspace, targetQubits[i]);
458  if (pauliCodes[i] == PAULI_Z)
459  statevec_pauliZ(workspace, targetQubits[i]);
460  }
461 }

References PAULI_X, PAULI_Y, PAULI_Z, statevec_pauliX(), statevec_pauliY(), and statevec_pauliZ().

Referenced by statevec_applyPauliSum(), and statevec_calcExpecPauliProd().

◆ statevec_applyPauliSum()

void statevec_applyPauliSum ( Qureg  inQureg,
enum pauliOpType *  allCodes,
qreal *  termCoeffs,
int  numSumTerms,
Qureg  outQureg 
)

Definition at line 493 of file QuEST_common.c.

493  {
494 
495  int numQb = inQureg.numQubitsRepresented;
496  int targs[numQb];
497  for (int q=0; q < numQb; q++)
498  targs[q] = q;
499 
500  statevec_initBlankState(outQureg);
501 
502  for (int t=0; t < numSumTerms; t++) {
503  Complex coef = (Complex) {.real=termCoeffs[t], .imag=0};
504  Complex iden = (Complex) {.real=1, .imag=0};
505  Complex zero = (Complex) {.real=0, .imag=0};
506 
507  // outQureg += coef paulis(inQureg)
508  statevec_applyPauliProd(inQureg, targs, &allCodes[t*numQb], numQb);
509  statevec_setWeightedQureg(coef, inQureg, iden, outQureg, zero, outQureg);
510 
511  // undero paulis(inQureg), exploiting XX=YY=ZZ=I
512  statevec_applyPauliProd(inQureg, targs, &allCodes[t*numQb], numQb);
513  }
514 }

References Qureg::numQubitsRepresented, Complex::real, statevec_applyPauliProd(), statevec_initBlankState(), and statevec_setWeightedQureg().

Referenced by applyPauliSum().

◆ statevec_calcExpecPauliProd()

qreal statevec_calcExpecPauliProd ( Qureg  qureg,
int *  targetQubits,
enum pauliOpType *  pauliCodes,
int  numTargets,
Qureg  workspace 
)

Definition at line 464 of file QuEST_common.c.

464  {
465 
466  statevec_cloneQureg(workspace, qureg);
467  statevec_applyPauliProd(workspace, targetQubits, pauliCodes, numTargets);
468 
469  // compute the expected value
470  qreal value;
471  if (qureg.isDensityMatrix)
472  value = densmatr_calcTotalProb(workspace); // Trace(ops qureg)
473  else
474  value = statevec_calcInnerProduct(workspace, qureg).real; // <qureg|ops|qureg>
475 
476  return value;
477 }

References densmatr_calcTotalProb(), Qureg::isDensityMatrix, qreal, Complex::real, statevec_applyPauliProd(), statevec_calcInnerProduct(), and statevec_cloneQureg().

Referenced by calcExpecPauliProd(), and statevec_calcExpecPauliSum().

◆ statevec_calcExpecPauliSum()

qreal statevec_calcExpecPauliSum ( Qureg  qureg,
enum pauliOpType *  allCodes,
qreal *  termCoeffs,
int  numSumTerms,
Qureg  workspace 
)

Definition at line 479 of file QuEST_common.c.

479  {
480 
481  int numQb = qureg.numQubitsRepresented;
482  int targs[numQb];
483  for (int q=0; q < numQb; q++)
484  targs[q] = q;
485 
486  qreal value = 0;
487  for (int t=0; t < numSumTerms; t++)
488  value += termCoeffs[t] * statevec_calcExpecPauliProd(qureg, targs, &allCodes[t*numQb], numQb, workspace);
489 
490  return value;
491 }

References Qureg::numQubitsRepresented, qreal, and statevec_calcExpecPauliProd().

Referenced by calcExpecPauliSum().

◆ statevec_calcFidelity()

qreal statevec_calcFidelity ( Qureg  qureg,
Qureg  pureState 
)

Definition at line 376 of file QuEST_common.c.

376  {
377 
378  Complex innerProd = statevec_calcInnerProduct(qureg, pureState);
379  qreal innerProdMag = innerProd.real*innerProd.real + innerProd.imag*innerProd.imag;
380  return innerProdMag;
381 }

References Complex::imag, qreal, Complex::real, and statevec_calcInnerProduct().

Referenced by calcFidelity().

◆ statevec_controlledMultiQubitUnitary()

void statevec_controlledMultiQubitUnitary ( Qureg  qureg,
int  ctrl,
int *  targets,
const int  numTargets,
ComplexMatrixN  u 
)

Definition at line 534 of file QuEST_common.c.

534  {
535 
536  long long int ctrlMask = 1LL << ctrl;
537  statevec_multiControlledMultiQubitUnitary(qureg, ctrlMask, targets, numTargets, u);
538 }

References statevec_multiControlledMultiQubitUnitary().

Referenced by controlledMultiQubitUnitary().

◆ statevec_controlledRotateAroundAxis()

void statevec_controlledRotateAroundAxis ( Qureg  qureg,
const int  controlQubit,
const int  targetQubit,
qreal  angle,
Vector  axis 
)

Definition at line 326 of file QuEST_common.c.

326  {
327 
328  Complex alpha, beta;
329  getComplexPairFromRotation(angle, axis, &alpha, &beta);
330  statevec_controlledCompactUnitary(qureg, controlQubit, targetQubit, alpha, beta);
331 }

References getComplexPairFromRotation(), and statevec_controlledCompactUnitary().

Referenced by controlledRotateAroundAxis(), statevec_controlledRotateX(), statevec_controlledRotateY(), and statevec_controlledRotateZ().

◆ statevec_controlledRotateAroundAxisConj()

void statevec_controlledRotateAroundAxisConj ( Qureg  qureg,
const int  controlQubit,
const int  targetQubit,
qreal  angle,
Vector  axis 
)

Definition at line 333 of file QuEST_common.c.

333  {
334 
335  Complex alpha, beta;
336  getComplexPairFromRotation(angle, axis, &alpha, &beta);
337  alpha.imag *= -1;
338  beta.imag *= -1;
339  statevec_controlledCompactUnitary(qureg, controlQubit, targetQubit, alpha, beta);
340 }

References getComplexPairFromRotation(), Complex::imag, and statevec_controlledCompactUnitary().

Referenced by controlledRotateAroundAxis().

◆ statevec_controlledRotateX()

void statevec_controlledRotateX ( Qureg  qureg,
const int  controlQubit,
const int  targetQubit,
qreal  angle 
)

Definition at line 342 of file QuEST_common.c.

342  {
343 
344  Vector unitAxis = {1, 0, 0};
345  statevec_controlledRotateAroundAxis(qureg, controlQubit, targetQubit, angle, unitAxis);
346 }

References statevec_controlledRotateAroundAxis().

Referenced by controlledRotateX().

◆ statevec_controlledRotateY()

void statevec_controlledRotateY ( Qureg  qureg,
const int  controlQubit,
const int  targetQubit,
qreal  angle 
)

Definition at line 348 of file QuEST_common.c.

348  {
349 
350  Vector unitAxis = {0, 1, 0};
351  statevec_controlledRotateAroundAxis(qureg, controlQubit, targetQubit, angle, unitAxis);
352 }

References statevec_controlledRotateAroundAxis().

Referenced by controlledRotateY().

◆ statevec_controlledRotateZ()

void statevec_controlledRotateZ ( Qureg  qureg,
const int  controlQubit,
const int  targetQubit,
qreal  angle 
)

Definition at line 354 of file QuEST_common.c.

354  {
355 
356  Vector unitAxis = {0, 0, 1};
357  statevec_controlledRotateAroundAxis(qureg, controlQubit, targetQubit, angle, unitAxis);
358 }

References statevec_controlledRotateAroundAxis().

Referenced by controlledRotateZ().

◆ statevec_controlledTwoQubitUnitary()

void statevec_controlledTwoQubitUnitary ( Qureg  qureg,
const int  controlQubit,
const int  targetQubit1,
const int  targetQubit2,
ComplexMatrix4  u 
)

Definition at line 522 of file QuEST_common.c.

522  {
523 
524  long long int ctrlMask = 1LL << controlQubit;
525  statevec_multiControlledTwoQubitUnitary(qureg, ctrlMask, targetQubit1, targetQubit2, u);
526 }

References statevec_multiControlledTwoQubitUnitary().

Referenced by controlledTwoQubitUnitary().

◆ statevec_getProbAmp()

qreal statevec_getProbAmp ( Qureg  qureg,
long long int  index 
)

Definition at line 244 of file QuEST_common.c.

244  {
245  qreal real = statevec_getRealAmp(qureg, index);
246  qreal imag = statevec_getImagAmp(qureg, index);
247  return real*real + imag*imag;
248 }

References qreal, statevec_getImagAmp(), and statevec_getRealAmp().

Referenced by getProbAmp().

◆ statevec_measureWithStats()

int statevec_measureWithStats ( Qureg  qureg,
int  measureQubit,
qreal *  outcomeProb 
)

Definition at line 360 of file QuEST_common.c.

360  {
361 
362  qreal zeroProb = statevec_calcProbOfOutcome(qureg, measureQubit, 0);
363  int outcome = generateMeasurementOutcome(zeroProb, outcomeProb);
364  statevec_collapseToKnownProbOutcome(qureg, measureQubit, outcome, *outcomeProb);
365  return outcome;
366 }

References generateMeasurementOutcome(), qreal, statevec_calcProbOfOutcome(), and statevec_collapseToKnownProbOutcome().

Referenced by measure(), and measureWithStats().

◆ statevec_multiQubitUnitary()

void statevec_multiQubitUnitary ( Qureg  qureg,
int *  targets,
const int  numTargets,
ComplexMatrixN  u 
)

Definition at line 528 of file QuEST_common.c.

528  {
529 
530  long long int ctrlMask = 0;
531  statevec_multiControlledMultiQubitUnitary(qureg, ctrlMask, targets, numTargets, u);
532 }

References statevec_multiControlledMultiQubitUnitary().

Referenced by multiQubitUnitary().

◆ statevec_multiRotatePauli()

void statevec_multiRotatePauli ( Qureg  qureg,
int *  targetQubits,
enum pauliOpType *  targetPaulis,
int  numTargets,
qreal  angle,
int  applyConj 
)

applyConj=1 will apply conjugate operation, else applyConj=0

Definition at line 410 of file QuEST_common.c.

413  {
414  qreal fac = 1/sqrt(2);
415  Complex uRxAlpha = {.real = fac, .imag = 0}; // Rx(pi/2)* rotates Z -> Y
416  Complex uRxBeta = {.real = 0, .imag = (applyConj)? fac : -fac};
417  Complex uRyAlpha = {.real = fac, .imag = 0}; // Ry(-pi/2) rotates Z -> X
418  Complex uRyBeta = {.real = -fac, .imag = 0};
419 
420  // mask may be modified to remove superfluous Identity ops
421  long long int mask = getQubitBitMask(targetQubits, numTargets);
422 
423  // rotate basis so that exp(Z) will effect exp(Y) and exp(X)
424  for (int t=0; t < numTargets; t++) {
425  if (targetPaulis[t] == PAULI_I)
426  mask -= 1LL << targetQubits[t]; // remove target from mask
427  if (targetPaulis[t] == PAULI_X)
428  statevec_compactUnitary(qureg, targetQubits[t], uRyAlpha, uRyBeta);
429  if (targetPaulis[t] == PAULI_Y)
430  statevec_compactUnitary(qureg, targetQubits[t], uRxAlpha, uRxBeta);
431  // (targetPaulis[t] == 3) is Z basis
432  }
433 
434  // does nothing if there are no qubits to 'rotate'
435  if (mask != 0)
436  statevec_multiRotateZ(qureg, mask, (applyConj)? -angle : angle);
437 
438  // undo X and Y basis rotations
439  uRxBeta.imag *= -1;
440  uRyBeta.real *= -1;
441  for (int t=0; t < numTargets; t++) {
442  if (targetPaulis[t] == PAULI_X)
443  statevec_compactUnitary(qureg, targetQubits[t], uRyAlpha, uRyBeta);
444  if (targetPaulis[t] == PAULI_Y)
445  statevec_compactUnitary(qureg, targetQubits[t], uRxAlpha, uRxBeta);
446  }
447 }

References getQubitBitMask(), Complex::imag, PAULI_I, PAULI_X, PAULI_Y, qreal, Complex::real, statevec_compactUnitary(), and statevec_multiRotateZ().

Referenced by multiRotatePauli().

◆ statevec_pauliZ()

void statevec_pauliZ ( Qureg  qureg,
const int  targetQubit 
)

Definition at line 257 of file QuEST_common.c.

257  {
258  Complex term;
259  term.real = -1;
260  term.imag = 0;
261  statevec_phaseShiftByTerm(qureg, targetQubit, term);
262 }

References Complex::imag, Complex::real, and statevec_phaseShiftByTerm().

Referenced by pauliZ(), and statevec_applyPauliProd().

◆ statevec_phaseShift()

void statevec_phaseShift ( Qureg  qureg,
const int  targetQubit,
qreal  angle 
)

Definition at line 250 of file QuEST_common.c.

250  {
251  Complex term;
252  term.real = cos(angle);
253  term.imag = sin(angle);
254  statevec_phaseShiftByTerm(qureg, targetQubit, term);
255 }

References Complex::imag, Complex::real, and statevec_phaseShiftByTerm().

Referenced by phaseShift().

◆ statevec_rotateAroundAxis()

void statevec_rotateAroundAxis ( Qureg  qureg,
const int  rotQubit,
qreal  angle,
Vector  axis 
)

Definition at line 310 of file QuEST_common.c.

310  {
311 
312  Complex alpha, beta;
313  getComplexPairFromRotation(angle, axis, &alpha, &beta);
314  statevec_compactUnitary(qureg, rotQubit, alpha, beta);
315 }

References getComplexPairFromRotation(), and statevec_compactUnitary().

Referenced by rotateAroundAxis(), statevec_rotateX(), statevec_rotateY(), and statevec_rotateZ().

◆ statevec_rotateAroundAxisConj()

void statevec_rotateAroundAxisConj ( Qureg  qureg,
const int  rotQubit,
qreal  angle,
Vector  axis 
)

Definition at line 317 of file QuEST_common.c.

317  {
318 
319  Complex alpha, beta;
320  getComplexPairFromRotation(angle, axis, &alpha, &beta);
321  alpha.imag *= -1;
322  beta.imag *= -1;
323  statevec_compactUnitary(qureg, rotQubit, alpha, beta);
324 }

References getComplexPairFromRotation(), Complex::imag, and statevec_compactUnitary().

Referenced by rotateAroundAxis().

◆ statevec_rotateX()

void statevec_rotateX ( Qureg  qureg,
const int  rotQubit,
qreal  angle 
)

Definition at line 292 of file QuEST_common.c.

292  {
293 
294  Vector unitAxis = {1, 0, 0};
295  statevec_rotateAroundAxis(qureg, rotQubit, angle, unitAxis);
296 }

References statevec_rotateAroundAxis().

Referenced by rotateX().

◆ statevec_rotateY()

void statevec_rotateY ( Qureg  qureg,
const int  rotQubit,
qreal  angle 
)

Definition at line 298 of file QuEST_common.c.

298  {
299 
300  Vector unitAxis = {0, 1, 0};
301  statevec_rotateAroundAxis(qureg, rotQubit, angle, unitAxis);
302 }

References statevec_rotateAroundAxis().

Referenced by rotateY().

◆ statevec_rotateZ()

void statevec_rotateZ ( Qureg  qureg,
const int  rotQubit,
qreal  angle 
)

Definition at line 304 of file QuEST_common.c.

304  {
305 
306  Vector unitAxis = {0, 0, 1};
307  statevec_rotateAroundAxis(qureg, rotQubit, angle, unitAxis);
308 }

References statevec_rotateAroundAxis().

Referenced by rotateZ().

◆ statevec_sGate()

void statevec_sGate ( Qureg  qureg,
const int  targetQubit 
)

Definition at line 264 of file QuEST_common.c.

264  {
265  Complex term;
266  term.real = 0;
267  term.imag = 1;
268  statevec_phaseShiftByTerm(qureg, targetQubit, term);
269 }

References Complex::imag, Complex::real, and statevec_phaseShiftByTerm().

Referenced by sGate().

◆ statevec_sGateConj()

void statevec_sGateConj ( Qureg  qureg,
const int  targetQubit 
)

Definition at line 278 of file QuEST_common.c.

278  {
279  Complex term;
280  term.real = 0;
281  term.imag = -1;
282  statevec_phaseShiftByTerm(qureg, targetQubit, term);
283 }

References Complex::imag, Complex::real, and statevec_phaseShiftByTerm().

Referenced by sGate().

◆ statevec_sqrtSwapGate()

void statevec_sqrtSwapGate ( Qureg  qureg,
int  qb1,
int  qb2 
)

Definition at line 383 of file QuEST_common.c.

383  {
384 
385  ComplexMatrix4 u = (ComplexMatrix4) {.real={{0}}, .imag={{0}}};
386  u.real[0][0]=1;
387  u.real[3][3]=1;
388  u.real[1][1] = .5; u.imag[1][1] = .5;
389  u.real[1][2] = .5; u.imag[1][2] =-.5;
390  u.real[2][1] = .5; u.imag[2][1] =-.5;
391  u.real[2][2] = .5; u.imag[2][2] = .5;
392 
393  statevec_twoQubitUnitary(qureg, qb1, qb2, u);
394 }

References ComplexMatrix4::imag, ComplexMatrix4::real, and statevec_twoQubitUnitary().

Referenced by sqrtSwapGate().

◆ statevec_sqrtSwapGateConj()

void statevec_sqrtSwapGateConj ( Qureg  qureg,
int  qb1,
int  qb2 
)

Definition at line 396 of file QuEST_common.c.

396  {
397 
398  ComplexMatrix4 u = (ComplexMatrix4) {.real={{0}}, .imag={{0}}};
399  u.real[0][0]=1;
400  u.real[3][3]=1;
401  u.real[1][1] = .5; u.imag[1][1] =-.5;
402  u.real[1][2] = .5; u.imag[1][2] = .5;
403  u.real[2][1] = .5; u.imag[2][1] = .5;
404  u.real[2][2] = .5; u.imag[2][2] =-.5;
405 
406  statevec_twoQubitUnitary(qureg, qb1, qb2, u);
407 }

References ComplexMatrix4::imag, ComplexMatrix4::real, and statevec_twoQubitUnitary().

Referenced by sqrtSwapGate().

◆ statevec_tGate()

void statevec_tGate ( Qureg  qureg,
const int  targetQubit 
)

Definition at line 271 of file QuEST_common.c.

271  {
272  Complex term;
273  term.real = 1/sqrt(2);
274  term.imag = 1/sqrt(2);
275  statevec_phaseShiftByTerm(qureg, targetQubit, term);
276 }

References Complex::imag, Complex::real, and statevec_phaseShiftByTerm().

Referenced by tGate().

◆ statevec_tGateConj()

void statevec_tGateConj ( Qureg  qureg,
const int  targetQubit 
)

Definition at line 285 of file QuEST_common.c.

285  {
286  Complex term;
287  term.real = 1/sqrt(2);
288  term.imag = -1/sqrt(2);
289  statevec_phaseShiftByTerm(qureg, targetQubit, term);
290 }

References Complex::imag, Complex::real, and statevec_phaseShiftByTerm().

Referenced by tGate().

◆ statevec_twoQubitUnitary()

void statevec_twoQubitUnitary ( Qureg  qureg,
const int  targetQubit1,
const int  targetQubit2,
ComplexMatrix4  u 
)

Definition at line 516 of file QuEST_common.c.

516  {
517 
518  long long int ctrlMask = 0;
519  statevec_multiControlledTwoQubitUnitary(qureg, ctrlMask, targetQubit1, targetQubit2, u);
520 }

References statevec_multiControlledTwoQubitUnitary().

Referenced by statevec_sqrtSwapGate(), statevec_sqrtSwapGateConj(), and twoQubitUnitary().

Vector
Represents a 3-vector of real numbers.
Definition: QuEST.h:148
macro_setConjugateMatrix
#define macro_setConjugateMatrix(dest, src, dim)
Definition: QuEST_common.c:92
ComplexMatrix4::real
qreal real[4][4]
Definition: QuEST.h:127
densmatr_mixKrausMap
void densmatr_mixKrausMap(Qureg qureg, int target, ComplexMatrix2 *ops, int numOps)
Definition: QuEST_common.c:599
PAULI_Z
@ PAULI_Z
Definition: QuEST.h:96
statevec_pauliY
void statevec_pauliY(Qureg qureg, const int targetQubit)
Definition: QuEST_cpu_distributed.c:1092
populateKrausSuperOperator4
void populateKrausSuperOperator4(ComplexMatrixN *superOp, ComplexMatrix4 *ops, int numOps)
Definition: QuEST_common.c:566
populateKrausSuperOperatorN
void populateKrausSuperOperatorN(ComplexMatrixN *superOp, ComplexMatrixN *ops, int numOps)
Definition: QuEST_common.c:570
destroyComplexMatrixN
void destroyComplexMatrixN(ComplexMatrixN m)
Destroy a ComplexMatrixN instance created with createComplexMatrixN()
Definition: QuEST.c:1021
statevec_calcExpecPauliProd
qreal statevec_calcExpecPauliProd(Qureg qureg, int *targetQubits, enum pauliOpType *pauliCodes, int numTargets, Qureg workspace)
Definition: QuEST_common.c:464
PAULI_I
@ PAULI_I
Definition: QuEST.h:96
createComplexMatrixN
ComplexMatrixN createComplexMatrixN(int numQubits)
Create (dynamically) a square complex matrix which can be passed to the multi-qubit general unitary f...
Definition: QuEST.c:1000
Vector::z
qreal z
Definition: QuEST.h:150
statevec_applyPauliProd
void statevec_applyPauliProd(Qureg workspace, int *targetQubits, enum pauliOpType *pauliCodes, int numTargets)
Definition: QuEST_common.c:450
statevec_multiRotateZ
void statevec_multiRotateZ(Qureg qureg, long long int mask, qreal angle)
Definition: QuEST_cpu.c:3069
statevec_multiControlledMultiQubitUnitary
void statevec_multiControlledMultiQubitUnitary(Qureg qureg, long long int ctrlMask, int *targs, const int numTargs, ComplexMatrixN u)
This calls swapQubitAmps only when it would involve a distributed communication; if the qubit chunks ...
Definition: QuEST_cpu_distributed.c:1441
densmatr_collapseToKnownProbOutcome
void densmatr_collapseToKnownProbOutcome(Qureg qureg, const int measureQubit, int outcome, qreal outcomeProb)
Renorms (/prob) every | * outcome * >< * outcome * | state, setting all others to zero.
Definition: QuEST_cpu.c:784
statevec_pauliX
void statevec_pauliX(Qureg qureg, const int targetQubit)
Definition: QuEST_cpu_distributed.c:1036
getUnitVector
Vector getUnitVector(Vector vec)
Definition: QuEST_common.c:77
ComplexMatrix4
Represents a 4x4 matrix of complex numbers.
Definition: QuEST.h:125
getComplexPairFromRotation
void getComplexPairFromRotation(qreal angle, Vector axis, Complex *alpha, Complex *beta)
Definition: QuEST_common.c:113
bindArraysToStackComplexMatrixN
ComplexMatrixN bindArraysToStackComplexMatrixN(int numQubits, qreal re[][1<< numQubits], qreal im[][1<< numQubits], qreal **reStorage, qreal **imStorage)
Definition: QuEST_common.c:606
ComplexMatrixN
Represents a general 2^N by 2^N matrix of complex numbers.
Definition: QuEST.h:136
qreal
#define qreal
macro_allocStackComplexMatrixN
#define macro_allocStackComplexMatrixN(matrix, numQubits)
Definition: QuEST_common.c:628
PAULI_X
@ PAULI_X
Definition: QuEST.h:96
densmatr_calcTotalProb
qreal densmatr_calcTotalProb(Qureg qureg)
Definition: QuEST_cpu_distributed.c:53
getQubitBitMask
long long int getQubitBitMask(int *qubits, const int numQubits)
Definition: QuEST_common.c:43
Vector::y
qreal y
Definition: QuEST.h:150
ComplexMatrix2::imag
qreal imag[2][2]
Definition: QuEST.h:117
Vector::x
qreal x
Definition: QuEST.h:150
generateMeasurementOutcome
int generateMeasurementOutcome(qreal zeroProb, qreal *outcomeProb)
Definition: QuEST_common.c:154
statevec_twoQubitUnitary
void statevec_twoQubitUnitary(Qureg qureg, const int targetQubit1, const int targetQubit2, ComplexMatrix4 u)
Definition: QuEST_common.c:516
statevec_pauliZ
void statevec_pauliZ(Qureg qureg, const int targetQubit)
Definition: QuEST_common.c:257
densmatr_applyKrausSuperoperator
void densmatr_applyKrausSuperoperator(Qureg qureg, int target, ComplexMatrix4 superOp)
Definition: QuEST_common.c:575
statevec_initBlankState
void statevec_initBlankState(Qureg qureg)
Definition: QuEST_cpu.c:1366
populateKrausSuperOperator2
void populateKrausSuperOperator2(ComplexMatrix4 *superOp, ComplexMatrix2 *ops, int numOps)
Definition: QuEST_common.c:562
statevec_cloneQureg
void statevec_cloneQureg(Qureg targetQureg, Qureg copyQureg)
works for both statevectors and density matrices
Definition: QuEST_cpu.c:1474
ComplexMatrix4::imag
qreal imag[4][4]
Definition: QuEST.h:128
statevec_phaseShiftByTerm
void statevec_phaseShiftByTerm(Qureg qureg, const int targetQubit, Complex term)
Definition: QuEST_cpu.c:2940
PAULI_Y
@ PAULI_Y
Definition: QuEST.h:96
genrand_real1
double genrand_real1(void)
Definition: mt19937ar.c:150
ComplexMatrixN::real
qreal ** real
Definition: QuEST.h:139
statevec_calcInnerProduct
Complex statevec_calcInnerProduct(Qureg bra, Qureg ket)
Terrible code which unnecessarily individually computes and sums the real and imaginary components of...
Definition: QuEST_cpu_distributed.c:35
statevec_setWeightedQureg
void statevec_setWeightedQureg(Complex fac1, Qureg qureg1, Complex fac2, Qureg qureg2, Complex facOut, Qureg out)
Definition: QuEST_cpu.c:3579
statevec_calcProbOfOutcome
qreal statevec_calcProbOfOutcome(Qureg qureg, const int measureQubit, int outcome)
Definition: QuEST_cpu_distributed.c:1263
statevec_collapseToKnownProbOutcome
void statevec_collapseToKnownProbOutcome(Qureg qureg, const int measureQubit, int outcome, qreal outcomeProb)
Definition: QuEST_cpu_distributed.c:1301
statevec_getImagAmp
qreal statevec_getImagAmp(Qureg qureg, long long int index)
Definition: QuEST_cpu_distributed.c:208
ComplexMatrixN::imag
qreal ** imag
Definition: QuEST.h:140
densmatr_calcProbOfOutcome
qreal densmatr_calcProbOfOutcome(Qureg qureg, const int measureQubit, int outcome)
Definition: QuEST_cpu_distributed.c:1279
ComplexMatrix2::real
qreal real[2][2]
Definition: QuEST.h:116
Qureg::isDensityMatrix
int isDensityMatrix
Whether this instance is a density-state representation.
Definition: QuEST.h:163
statevec_controlledCompactUnitary
void statevec_controlledCompactUnitary(Qureg qureg, const int controlQubit, const int targetQubit, Complex alpha, Complex beta)
Definition: QuEST_cpu_distributed.c:922
ComplexMatrixN::numQubits
int numQubits
Definition: QuEST.h:138
getVectorMagnitude
qreal getVectorMagnitude(Vector vec)
Definition: QuEST_common.c:72
densmatr_applyTwoQubitKrausSuperoperator
void densmatr_applyTwoQubitKrausSuperoperator(Qureg qureg, int target1, int target2, ComplexMatrixN superOp)
Definition: QuEST_common.c:581
Qureg::numQubitsRepresented
int numQubitsRepresented
The number of qubits represented in either the state-vector or density matrix.
Definition: QuEST.h:165
Complex::real
qreal real
Definition: QuEST.h:105
densmatr_applyMultiQubitKrausSuperoperator
void densmatr_applyMultiQubitKrausSuperoperator(Qureg qureg, int *targets, int numTargets, ComplexMatrixN superOp)
Definition: QuEST_common.c:589
Complex::imag
qreal imag
Definition: QuEST.h:106
statevec_controlledRotateAroundAxis
void statevec_controlledRotateAroundAxis(Qureg qureg, const int controlQubit, const int targetQubit, qreal angle, Vector axis)
Definition: QuEST_common.c:326
Complex
Represents one complex number.
Definition: QuEST.h:103
statevec_rotateAroundAxis
void statevec_rotateAroundAxis(Qureg qureg, const int rotQubit, qreal angle, Vector axis)
Definition: QuEST_common.c:310
statevec_multiControlledTwoQubitUnitary
void statevec_multiControlledTwoQubitUnitary(Qureg qureg, long long int ctrlMask, const int targetQubit1, const int targetQubit2, ComplexMatrix4 u)
This calls swapQubitAmps only when it would involve a distributed communication; if the qubit chunks ...
Definition: QuEST_cpu_distributed.c:1385
macro_populateKrausOperator
#define macro_populateKrausOperator(superOp, ops, numOps, opDim)
Definition: QuEST_common.c:540
statevec_getRealAmp
qreal statevec_getRealAmp(Qureg qureg, long long int index)
Definition: QuEST_cpu_distributed.c:198
ComplexMatrix2
Represents a 2x2 matrix of complex numbers.
Definition: QuEST.h:114
statevec_compactUnitary
void statevec_compactUnitary(Qureg qureg, const int targetQubit, Complex alpha, Complex beta)
Definition: QuEST_cpu_distributed.c:846