QuEST_common.c File Reference
#include "QuEST.h"
#include "QuEST_internal.h"
#include "QuEST_precision.h"
#include "QuEST_validation.h"
#include "QuEST_qasm.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

void agnostic_applyTrotterCircuit (Qureg qureg, PauliHamil hamil, qreal time, int order, int reps)
 
void applyExponentiatedPauliHamil (Qureg qureg, PauliHamil hamil, qreal fac, int reverse)
 
void applySymmetrizedTrotterCircuit (Qureg qureg, PauliHamil hamil, qreal time, int order)
 
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, int numControlQubits)
 
long long int getQubitBitMask (int *qubits, 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, int numTargets, ComplexMatrixN u)
 
void statevec_controlledRotateAroundAxis (Qureg qureg, int controlQubit, int targetQubit, qreal angle, Vector axis)
 
void statevec_controlledRotateAroundAxisConj (Qureg qureg, int controlQubit, int targetQubit, qreal angle, Vector axis)
 
void statevec_controlledRotateX (Qureg qureg, int controlQubit, int targetQubit, qreal angle)
 
void statevec_controlledRotateY (Qureg qureg, int controlQubit, int targetQubit, qreal angle)
 
void statevec_controlledRotateZ (Qureg qureg, int controlQubit, int targetQubit, qreal angle)
 
void statevec_controlledTwoQubitUnitary (Qureg qureg, int controlQubit, int targetQubit1, 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, 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, int targetQubit)
 
void statevec_phaseShift (Qureg qureg, int targetQubit, qreal angle)
 
void statevec_rotateAroundAxis (Qureg qureg, int rotQubit, qreal angle, Vector axis)
 
void statevec_rotateAroundAxisConj (Qureg qureg, int rotQubit, qreal angle, Vector axis)
 
void statevec_rotateX (Qureg qureg, int rotQubit, qreal angle)
 
void statevec_rotateY (Qureg qureg, int rotQubit, qreal angle)
 
void statevec_rotateZ (Qureg qureg, int rotQubit, qreal angle)
 
void statevec_sGate (Qureg qureg, int targetQubit)
 
void statevec_sGateConj (Qureg qureg, 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, int targetQubit)
 
void statevec_tGateConj (Qureg qureg, int targetQubit)
 
void statevec_twoQubitUnitary (Qureg qureg, int targetQubit1, 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 629 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 623 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 541 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 93 of file QuEST_common.c.

Function Documentation

◆ agnostic_applyTrotterCircuit()

void agnostic_applyTrotterCircuit ( Qureg  qureg,
PauliHamil  hamil,
qreal  time,
int  order,
int  reps 
)

Definition at line 773 of file QuEST_common.c.

773  {
774 
775  if (time == 0)
776  return;
777 
778  for (int r=0; r<reps; r++)
779  applySymmetrizedTrotterCircuit(qureg, hamil, time/reps, order);
780 }

References applySymmetrizedTrotterCircuit().

Referenced by applyTrotterCircuit().

◆ applyExponentiatedPauliHamil()

void applyExponentiatedPauliHamil ( Qureg  qureg,
PauliHamil  hamil,
qreal  fac,
int  reverse 
)

Definition at line 698 of file QuEST_common.c.

698  {
699 
700  /* applies a first-order one-repetition approximation of exp(-i fac H)
701  * to qureg. Letting H = sum_j c_j h_j, it does this via
702  * exp(-i fac H) ~ prod_j exp(-i fac c_j h_j), where each inner exp
703  * is performed with multiRotatePauli (with pre-factor 2).
704  */
705 
706  // prepare targets for multiRotatePauli
707  // (all qubits; actual targets are determined by Pauli codes)
708  int vecTargs[hamil.numQubits];
709  int densTargs[hamil.numQubits];
710  for (int q=0; q<hamil.numQubits; q++) {
711  vecTargs[q] = q;
712  densTargs[q] = q + hamil.numQubits;
713  }
714 
715  for (int i=0; i<hamil.numSumTerms; i++) {
716 
717  int t=i;
718  if (reverse)
719  t=hamil.numSumTerms-1-i;
720 
721  qreal angle = 2*fac*hamil.termCoeffs[t];
722 
724  qureg, vecTargs, &(hamil.pauliCodes[t*hamil.numQubits]),
725  hamil.numQubits, angle, 0);
726 
727  if (qureg.isDensityMatrix)
729  qureg, densTargs, &(hamil.pauliCodes[t*hamil.numQubits]),
730  hamil.numQubits, angle, 1);
731 
732  // record qasm
733  char buff[1024];
734  int b=0;
735  for (int q=0; q<hamil.numQubits; q++) {
736  enum pauliOpType op = hamil.pauliCodes[q + t*hamil.numQubits];
737 
738  char p = 'I';
739  if (op == PAULI_X) p = 'X';
740  if (op == PAULI_Y) p = 'Y';
741  if (op == PAULI_Z) p = 'Z';
742  buff[b++] = p;
743  buff[b++] = ' ';
744  }
745  buff[b] = '\0';
746 
747  qasm_recordComment(qureg,
748  "Here, a multiRotatePauli with angle %g and paulis %s was applied.",
749  angle, buff);
750  }
751 }

References Qureg::isDensityMatrix, PauliHamil::numQubits, PauliHamil::numSumTerms, PAULI_X, PAULI_Y, PAULI_Z, PauliHamil::pauliCodes, qasm_recordComment(), qreal, statevec_multiRotatePauli(), and PauliHamil::termCoeffs.

Referenced by applySymmetrizedTrotterCircuit().

◆ applySymmetrizedTrotterCircuit()

void applySymmetrizedTrotterCircuit ( Qureg  qureg,
PauliHamil  hamil,
qreal  time,
int  order 
)

Definition at line 753 of file QuEST_common.c.

753  {
754 
755  if (order == 1) {
756  applyExponentiatedPauliHamil(qureg, hamil, time, 0);
757  }
758  else if (order == 2) {
759  applyExponentiatedPauliHamil(qureg, hamil, time/2., 0);
760  applyExponentiatedPauliHamil(qureg, hamil, time/2., 1);
761  }
762  else {
763  qreal p = 1. / (4 - pow(4, 1./(order-1)));
764  int lower = order-2;
765  applySymmetrizedTrotterCircuit(qureg, hamil, p*time, lower);
766  applySymmetrizedTrotterCircuit(qureg, hamil, p*time, lower);
767  applySymmetrizedTrotterCircuit(qureg, hamil, (1-4*p)*time, lower);
768  applySymmetrizedTrotterCircuit(qureg, hamil, p*time, lower);
769  applySymmetrizedTrotterCircuit(qureg, hamil, p*time, lower);
770  }
771 }

References applyExponentiatedPauliHamil(), and qreal.

Referenced by agnostic_applyTrotterCircuit().

◆ bindArraysToStackComplexMatrixN()

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

Definition at line 607 of file QuEST_common.c.

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

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

◆ densmatr_applyKrausSuperoperator()

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

Definition at line 576 of file QuEST_common.c.

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

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 590 of file QuEST_common.c.

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

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 582 of file QuEST_common.c.

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

References Qureg::numQubitsRepresented, and statevec_multiControlledMultiQubitUnitary().

Referenced by densmatr_mixTwoQubitKrausMap().

◆ densmatr_measureWithStats()

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

Definition at line 369 of file QuEST_common.c.

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

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 600 of file QuEST_common.c.

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

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 643 of file QuEST_common.c.

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

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 676 of file QuEST_common.c.

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

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 635 of file QuEST_common.c.

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

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

Referenced by mixTwoQubitKrausMap().

◆ ensureIndsIncrease()

void ensureIndsIncrease ( int *  ind1,
int *  ind2 
)

Definition at line 64 of file QuEST_common.c.

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

Referenced by mixTwoQubitDephasing(), and mixTwoQubitDepolarising().

◆ generateMeasurementOutcome()

int generateMeasurementOutcome ( qreal  zeroProb,
qreal outcomeProb 
)

Definition at line 155 of file QuEST_common.c.

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

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 136 of file QuEST_common.c.

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

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 114 of file QuEST_common.c.

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

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 99 of file QuEST_common.c.

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

References macro_setConjugateMatrix.

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

◆ getConjugateMatrix4()

ComplexMatrix4 getConjugateMatrix4 ( ComplexMatrix4  src)

Definition at line 104 of file QuEST_common.c.

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

References macro_setConjugateMatrix.

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

◆ getConjugateScalar()

Complex getConjugateScalar ( Complex  scalar)

Definition at line 85 of file QuEST_common.c.

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

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

Referenced by compactUnitary(), and controlledCompactUnitary().

◆ getControlFlipMask()

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

Definition at line 54 of file QuEST_common.c.

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

Referenced by multiStateControlledUnitary().

◆ getQubitBitMask()

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

◆ getQuESTDefaultSeedKey()

void getQuESTDefaultSeedKey ( unsigned long int *  key)

Definition at line 182 of file QuEST_common.c.

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

Referenced by seedQuESTDefault().

◆ getUnitVector()

Vector getUnitVector ( Vector  vec)

Definition at line 78 of file QuEST_common.c.

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

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

Referenced by getComplexPairFromRotation().

◆ getVectorMagnitude()

qreal getVectorMagnitude ( Vector  vec)

Definition at line 73 of file QuEST_common.c.

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

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 124 of file QuEST_common.c.

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

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 172 of file QuEST_common.c.

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

◆ populateKrausSuperOperator2()

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

Definition at line 563 of file QuEST_common.c.

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

References macro_populateKrausOperator.

Referenced by densmatr_mixKrausMap().

◆ populateKrausSuperOperator4()

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

Definition at line 567 of file QuEST_common.c.

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

References macro_populateKrausOperator.

Referenced by densmatr_mixTwoQubitKrausMap().

◆ populateKrausSuperOperatorN()

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

Definition at line 571 of file QuEST_common.c.

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

References macro_populateKrausOperator, and ComplexMatrixN::numQubits.

Referenced by densmatr_mixMultiQubitKrausMap().

◆ setConjugateMatrixN()

void setConjugateMatrixN ( ComplexMatrixN  m)

Definition at line 109 of file QuEST_common.c.

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

References macro_setConjugateMatrix, and ComplexMatrixN::numQubits.

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

◆ shiftIndices()

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

Definition at line 150 of file QuEST_common.c.

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

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 451 of file QuEST_common.c.

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

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 494 of file QuEST_common.c.

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

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

Referenced by applyPauliHamil(), and applyPauliSum().

◆ statevec_calcExpecPauliProd()

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

Definition at line 465 of file QuEST_common.c.

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

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 480 of file QuEST_common.c.

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

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

Referenced by calcExpecPauliHamil(), and calcExpecPauliSum().

◆ statevec_calcFidelity()

qreal statevec_calcFidelity ( Qureg  qureg,
Qureg  pureState 
)

Definition at line 377 of file QuEST_common.c.

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

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

Referenced by calcFidelity().

◆ statevec_controlledMultiQubitUnitary()

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

Definition at line 535 of file QuEST_common.c.

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

References statevec_multiControlledMultiQubitUnitary().

Referenced by controlledMultiQubitUnitary().

◆ statevec_controlledRotateAroundAxis()

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

Definition at line 327 of file QuEST_common.c.

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

References getComplexPairFromRotation(), and statevec_controlledCompactUnitary().

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

◆ statevec_controlledRotateAroundAxisConj()

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

Definition at line 334 of file QuEST_common.c.

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

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

Referenced by controlledRotateAroundAxis().

◆ statevec_controlledRotateX()

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

Definition at line 343 of file QuEST_common.c.

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

References statevec_controlledRotateAroundAxis().

Referenced by controlledRotateX().

◆ statevec_controlledRotateY()

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

Definition at line 349 of file QuEST_common.c.

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

References statevec_controlledRotateAroundAxis().

Referenced by controlledRotateY().

◆ statevec_controlledRotateZ()

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

Definition at line 355 of file QuEST_common.c.

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

References statevec_controlledRotateAroundAxis().

Referenced by controlledRotateZ().

◆ statevec_controlledTwoQubitUnitary()

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

Definition at line 523 of file QuEST_common.c.

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

References statevec_multiControlledTwoQubitUnitary().

Referenced by controlledTwoQubitUnitary().

◆ statevec_getProbAmp()

qreal statevec_getProbAmp ( Qureg  qureg,
long long int  index 
)

Definition at line 245 of file QuEST_common.c.

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

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

Referenced by getProbAmp().

◆ statevec_measureWithStats()

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

Definition at line 361 of file QuEST_common.c.

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

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

Referenced by measure(), and measureWithStats().

◆ statevec_multiQubitUnitary()

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

Definition at line 529 of file QuEST_common.c.

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

References statevec_multiControlledMultiQubitUnitary().

Referenced by applyMatrixN(), and 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 411 of file QuEST_common.c.

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

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

Referenced by applyExponentiatedPauliHamil(), and multiRotatePauli().

◆ statevec_pauliZ()

void statevec_pauliZ ( Qureg  qureg,
int  targetQubit 
)

Definition at line 258 of file QuEST_common.c.

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

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

Referenced by pauliZ(), and statevec_applyPauliProd().

◆ statevec_phaseShift()

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

Definition at line 251 of file QuEST_common.c.

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

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

Referenced by phaseShift().

◆ statevec_rotateAroundAxis()

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

Definition at line 311 of file QuEST_common.c.

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

References getComplexPairFromRotation(), and statevec_compactUnitary().

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

◆ statevec_rotateAroundAxisConj()

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

Definition at line 318 of file QuEST_common.c.

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

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

Referenced by rotateAroundAxis().

◆ statevec_rotateX()

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

Definition at line 293 of file QuEST_common.c.

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

References statevec_rotateAroundAxis().

Referenced by rotateX().

◆ statevec_rotateY()

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

Definition at line 299 of file QuEST_common.c.

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

References statevec_rotateAroundAxis().

Referenced by rotateY().

◆ statevec_rotateZ()

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

Definition at line 305 of file QuEST_common.c.

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

References statevec_rotateAroundAxis().

Referenced by rotateZ().

◆ statevec_sGate()

void statevec_sGate ( Qureg  qureg,
int  targetQubit 
)

Definition at line 265 of file QuEST_common.c.

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

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

Referenced by sGate().

◆ statevec_sGateConj()

void statevec_sGateConj ( Qureg  qureg,
int  targetQubit 
)

Definition at line 279 of file QuEST_common.c.

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

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 384 of file QuEST_common.c.

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

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 397 of file QuEST_common.c.

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

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

Referenced by sqrtSwapGate().

◆ statevec_tGate()

void statevec_tGate ( Qureg  qureg,
int  targetQubit 
)

Definition at line 272 of file QuEST_common.c.

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

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

Referenced by tGate().

◆ statevec_tGateConj()

void statevec_tGateConj ( Qureg  qureg,
int  targetQubit 
)

Definition at line 286 of file QuEST_common.c.

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

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

Referenced by tGate().

◆ statevec_twoQubitUnitary()

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

Definition at line 517 of file QuEST_common.c.

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

References statevec_multiControlledTwoQubitUnitary().

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

Represents a 3-vector of real numbers.
Definition: QuEST.h:148
void statevec_pauliZ(Qureg qureg, int targetQubit)
Definition: QuEST_common.c:258
pauliOpType
Codes for specifying Pauli operators.
Definition: QuEST.h:96
#define macro_setConjugateMatrix(dest, src, dim)
Definition: QuEST_common.c:93
qreal real[4][4]
Definition: QuEST.h:127
void densmatr_mixKrausMap(Qureg qureg, int target, ComplexMatrix2 *ops, int numOps)
Definition: QuEST_common.c:600
@ PAULI_Z
Definition: QuEST.h:96
void applyExponentiatedPauliHamil(Qureg qureg, PauliHamil hamil, qreal fac, int reverse)
Definition: QuEST_common.c:698
void populateKrausSuperOperator4(ComplexMatrixN *superOp, ComplexMatrix4 *ops, int numOps)
Definition: QuEST_common.c:567
void populateKrausSuperOperatorN(ComplexMatrixN *superOp, ComplexMatrixN *ops, int numOps)
Definition: QuEST_common.c:571
void destroyComplexMatrixN(ComplexMatrixN m)
Destroy a ComplexMatrixN instance created with createComplexMatrixN()
Definition: QuEST.c:1120
qreal statevec_calcExpecPauliProd(Qureg qureg, int *targetQubits, enum pauliOpType *pauliCodes, int numTargets, Qureg workspace)
Definition: QuEST_common.c:465
@ PAULI_I
Definition: QuEST.h:96
ComplexMatrixN createComplexMatrixN(int numQubits)
Create (dynamically) a square complex matrix which can be passed to the multi-qubit general unitary f...
Definition: QuEST.c:1099
void statevec_twoQubitUnitary(Qureg qureg, int targetQubit1, int targetQubit2, ComplexMatrix4 u)
Definition: QuEST_common.c:517
qreal z
Definition: QuEST.h:150
void statevec_applyPauliProd(Qureg workspace, int *targetQubits, enum pauliOpType *pauliCodes, int numTargets)
Definition: QuEST_common.c:451
void statevec_multiControlledMultiQubitUnitary(Qureg qureg, long long int ctrlMask, int *targs, int numTargs, ComplexMatrixN u)
This calls swapQubitAmps only when it would involve a distributed communication; if the qubit chunks ...
void statevec_multiRotateZ(Qureg qureg, long long int mask, qreal angle)
Definition: QuEST_cpu.c:3109
qreal statevec_calcProbOfOutcome(Qureg qureg, int measureQubit, int outcome)
Vector getUnitVector(Vector vec)
Definition: QuEST_common.c:78
Represents a 4x4 matrix of complex numbers.
Definition: QuEST.h:125
void getComplexPairFromRotation(qreal angle, Vector axis, Complex *alpha, Complex *beta)
Definition: QuEST_common.c:114
void statevec_pauliY(Qureg qureg, int targetQubit)
ComplexMatrixN bindArraysToStackComplexMatrixN(int numQubits, qreal re[][1<< numQubits], qreal im[][1<< numQubits], qreal **reStorage, qreal **imStorage)
Definition: QuEST_common.c:607
Represents a general 2^N by 2^N matrix of complex numbers.
Definition: QuEST.h:136
#define qreal
#define macro_allocStackComplexMatrixN(matrix, numQubits)
Definition: QuEST_common.c:629
@ PAULI_X
Definition: QuEST.h:96
qreal densmatr_calcTotalProb(Qureg qureg)
void densmatr_collapseToKnownProbOutcome(Qureg qureg, int measureQubit, int outcome, qreal outcomeProb)
Renorms (/prob) every | * outcome * >< * outcome * | state, setting all others to zero.
Definition: QuEST_cpu.c:785
qreal y
Definition: QuEST.h:150
qreal imag[2][2]
Definition: QuEST.h:117
qreal x
Definition: QuEST.h:150
int generateMeasurementOutcome(qreal zeroProb, qreal *outcomeProb)
Definition: QuEST_common.c:155
qreal * termCoeffs
The coefficient of each Pauli product. This is a length numSumTerms array.
Definition: QuEST.h:164
void densmatr_applyKrausSuperoperator(Qureg qureg, int target, ComplexMatrix4 superOp)
Definition: QuEST_common.c:576
enum pauliOpType * pauliCodes
The Pauli operators acting on each qubit, flattened over every operator.
Definition: QuEST.h:162
void statevec_initBlankState(Qureg qureg)
Definition: QuEST_cpu.c:1398
void populateKrausSuperOperator2(ComplexMatrix4 *superOp, ComplexMatrix2 *ops, int numOps)
Definition: QuEST_common.c:563
void statevec_cloneQureg(Qureg targetQureg, Qureg copyQureg)
works for both statevectors and density matrices
Definition: QuEST_cpu.c:1506
void statevec_rotateAroundAxis(Qureg qureg, int rotQubit, qreal angle, Vector axis)
Definition: QuEST_common.c:311
qreal imag[4][4]
Definition: QuEST.h:128
void statevec_multiControlledTwoQubitUnitary(Qureg qureg, long long int ctrlMask, int targetQubit1, int targetQubit2, ComplexMatrix4 u)
This calls swapQubitAmps only when it would involve a distributed communication; if the qubit chunks ...
int numSumTerms
The number of terms in the weighted sum, or the number of Pauli products.
Definition: QuEST.h:166
long long int getQubitBitMask(int *qubits, int numQubits)
Definition: QuEST_common.c:44
void statevec_compactUnitary(Qureg qureg, int targetQubit, Complex alpha, Complex beta)
@ PAULI_Y
Definition: QuEST.h:96
double genrand_real1(void)
Definition: mt19937ar.c:150
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: QuEST_common.c:411
void qasm_recordComment(Qureg qureg, char *comment,...)
Definition: QuEST_qasm.c:120
qreal ** real
Definition: QuEST.h:139
void statevec_controlledRotateAroundAxis(Qureg qureg, int controlQubit, int targetQubit, qreal angle, Vector axis)
Definition: QuEST_common.c:327
Complex statevec_calcInnerProduct(Qureg bra, Qureg ket)
Terrible code which unnecessarily individually computes and sums the real and imaginary components of...
void statevec_setWeightedQureg(Complex fac1, Qureg qureg1, Complex fac2, Qureg qureg2, Complex facOut, Qureg out)
Definition: QuEST_cpu.c:3619
void statevec_collapseToKnownProbOutcome(Qureg qureg, int measureQubit, int outcome, qreal outcomeProb)
qreal statevec_getImagAmp(Qureg qureg, long long int index)
qreal ** imag
Definition: QuEST.h:140
qreal real[2][2]
Definition: QuEST.h:116
int isDensityMatrix
Whether this instance is a density-state representation.
Definition: QuEST.h:206
int numQubits
Definition: QuEST.h:138
qreal getVectorMagnitude(Vector vec)
Definition: QuEST_common.c:73
void densmatr_applyTwoQubitKrausSuperoperator(Qureg qureg, int target1, int target2, ComplexMatrixN superOp)
Definition: QuEST_common.c:582
void statevec_phaseShiftByTerm(Qureg qureg, int targetQubit, Complex term)
Definition: QuEST_cpu.c:2978
int numQubits
The number of qubits for which this Hamiltonian is defined.
Definition: QuEST.h:168
int numQubitsRepresented
The number of qubits represented in either the state-vector or density matrix.
Definition: QuEST.h:208
void statevec_pauliX(Qureg qureg, int targetQubit)
qreal real
Definition: QuEST.h:105
void densmatr_applyMultiQubitKrausSuperoperator(Qureg qureg, int *targets, int numTargets, ComplexMatrixN superOp)
Definition: QuEST_common.c:590
qreal imag
Definition: QuEST.h:106
Represents one complex number.
Definition: QuEST.h:103
#define macro_populateKrausOperator(superOp, ops, numOps, opDim)
Definition: QuEST_common.c:541
qreal densmatr_calcProbOfOutcome(Qureg qureg, int measureQubit, int outcome)
void applySymmetrizedTrotterCircuit(Qureg qureg, PauliHamil hamil, qreal time, int order)
Definition: QuEST_common.c:753
void statevec_controlledCompactUnitary(Qureg qureg, int controlQubit, int targetQubit, Complex alpha, Complex beta)
qreal statevec_getRealAmp(Qureg qureg, long long int index)
Represents a 2x2 matrix of complex numbers.
Definition: QuEST.h:114