Macros | Enumerations | Functions | Variables
QuEST_validation.c File Reference
#include "QuEST.h"
#include "QuEST_precision.h"
#include "QuEST_internal.h"
#include "QuEST_validation.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

Go to the source code of this file.

Macros

#define macro_isCompletelyPositiveMap(ops, numOps, opDim)
 
#define macro_isMatrixUnitary(m, dim, retVal)
 

Enumerations

enum  ErrorCode {
  E_SUCCESS =0, E_INVALID_NUM_RANKS, E_INVALID_NUM_CREATE_QUBITS, E_INVALID_QUBIT_INDEX,
  E_INVALID_TARGET_QUBIT, E_INVALID_CONTROL_QUBIT, E_INVALID_STATE_INDEX, E_INVALID_AMP_INDEX,
  E_INVALID_ELEM_INDEX, E_INVALID_NUM_AMPS, E_INVALID_NUM_ELEMS, E_INVALID_OFFSET_NUM_AMPS_QUREG,
  E_INVALID_OFFSET_NUM_ELEMS_DIAG, E_TARGET_IS_CONTROL, E_TARGET_IN_CONTROLS, E_CONTROL_TARGET_COLLISION,
  E_QUBITS_NOT_UNIQUE, E_TARGETS_NOT_UNIQUE, E_CONTROLS_NOT_UNIQUE, E_INVALID_NUM_QUBITS,
  E_INVALID_NUM_TARGETS, E_INVALID_NUM_CONTROLS, E_NON_UNITARY_MATRIX, E_NON_UNITARY_COMPLEX_PAIR,
  E_ZERO_VECTOR, E_SYS_TOO_BIG_TO_PRINT, E_COLLAPSE_STATE_ZERO_PROB, E_INVALID_QUBIT_OUTCOME,
  E_CANNOT_OPEN_FILE, E_SECOND_ARG_MUST_BE_STATEVEC, E_MISMATCHING_QUREG_DIMENSIONS, E_MISMATCHING_QUREG_TYPES,
  E_DEFINED_ONLY_FOR_STATEVECS, E_DEFINED_ONLY_FOR_DENSMATRS, E_INVALID_PROB, E_UNNORM_PROBS,
  E_INVALID_ONE_QUBIT_DEPHASE_PROB, E_INVALID_TWO_QUBIT_DEPHASE_PROB, E_INVALID_ONE_QUBIT_DEPOL_PROB, E_INVALID_TWO_QUBIT_DEPOL_PROB,
  E_INVALID_ONE_QUBIT_PAULI_PROBS, E_INVALID_CONTROLS_BIT_STATE, E_INVALID_PAULI_CODE, E_INVALID_NUM_SUM_TERMS,
  E_CANNOT_FIT_MULTI_QUBIT_MATRIX, E_INVALID_UNITARY_SIZE, E_COMPLEX_MATRIX_NOT_INIT, E_INVALID_NUM_ONE_QUBIT_KRAUS_OPS,
  E_INVALID_NUM_TWO_QUBIT_KRAUS_OPS, E_INVALID_NUM_N_QUBIT_KRAUS_OPS, E_INVALID_KRAUS_OPS, E_MISMATCHING_NUM_TARGS_KRAUS_SIZE,
  E_DISTRIB_QUREG_TOO_SMALL, E_DISTRIB_DIAG_OP_TOO_SMALL, E_NUM_AMPS_EXCEED_TYPE, E_INVALID_PAULI_HAMIL_PARAMS,
  E_INVALID_PAULI_HAMIL_FILE_PARAMS, E_CANNOT_PARSE_PAULI_HAMIL_FILE_COEFF, E_CANNOT_PARSE_PAULI_HAMIL_FILE_PAULI, E_INVALID_PAULI_HAMIL_FILE_PAULI_CODE,
  E_MISMATCHING_PAULI_HAMIL_QUREG_NUM_QUBITS, E_INVALID_TROTTER_ORDER, E_INVALID_TROTTER_REPS, E_MISMATCHING_QUREG_DIAGONAL_OP_SIZE,
  E_DIAGONAL_OP_NOT_INITIALISED, E_PAULI_HAMIL_NOT_DIAGONAL, E_MISMATCHING_PAULI_HAMIL_DIAGONAL_OP_SIZE, E_INVALID_NUM_SUBREGISTERS,
  E_INVALID_NUM_PHASE_FUNC_TERMS, E_INVALID_NUM_PHASE_FUNC_OVERRIDES, E_INVALID_PHASE_FUNC_OVERRIDE_UNSIGNED_INDEX, E_INVALID_PHASE_FUNC_OVERRIDE_TWOS_COMPLEMENT_INDEX,
  E_INVALID_PHASE_FUNC_NAME, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, E_INVALID_BIT_ENCODING, E_INVALID_NUM_QUBITS_TWOS_COMPLEMENT,
  E_NEGATIVE_EXPONENT_WITHOUT_ZERO_OVERRIDE, E_FRACTIONAL_EXPONENT_WITHOUT_NEG_OVERRIDE, E_NEGATIVE_EXPONENT_MULTI_VAR, E_FRACTIONAL_EXPONENT_MULTI_VAR,
  E_INVALID_NUM_REGS_DISTANCE_PHASE_FUNC
}
 

Functions

int areUniqueQubits (int *qubits, int numQubits)
 
unsigned int calcLog2 (long unsigned int num)
 returns log2 of numbers which must be gauranteed to be 2^n More...
 
void default_invalidQuESTInputError (const char *errMsg, const char *errFunc)
 
void invalidQuESTInputError (const char *errMsg, const char *errFunc)
 An internal function called when invalid arguments are passed to a QuEST API call, which the user can optionally override by redefining. More...
 
int isCompletelyPositiveMap2 (ComplexMatrix2 *ops, int numOps)
 
int isCompletelyPositiveMap4 (ComplexMatrix4 *ops, int numOps)
 
int isCompletelyPositiveMapN (ComplexMatrixN *ops, int numOps)
 
int isComplexPairUnitary (Complex alpha, Complex beta)
 
int isComplexUnit (Complex alpha)
 
int isMatrix2Unitary (ComplexMatrix2 u)
 
int isMatrix4Unitary (ComplexMatrix4 u)
 
int isMatrixNUnitary (ComplexMatrixN u)
 
int isValidPauliCode (enum pauliOpType code)
 
int isVectorUnit (qreal ux, qreal uy, qreal uz)
 
void QuESTAssert (int isValid, ErrorCode code, const char *func)
 
void validateAmpIndex (Qureg qureg, long long int ampInd, const char *caller)
 
void validateBitEncoding (int numQubits, enum bitEncoding encoding, const char *caller)
 
void validateControl (Qureg qureg, int controlQubit, const char *caller)
 
void validateControlState (int *controlState, int numControlQubits, const char *caller)
 
void validateControlTarget (Qureg qureg, int controlQubit, int targetQubit, const char *caller)
 
void validateDensityMatrQureg (Qureg qureg, const char *caller)
 
void validateDiagonalOp (Qureg qureg, DiagonalOp op, const char *caller)
 
void validateDiagOpInit (DiagonalOp op, const char *caller)
 
void validateDiagPauliHamil (DiagonalOp op, PauliHamil hamil, const char *caller)
 
void validateDiagPauliHamilFromFile (PauliHamil hamil, int numRanks, const char *caller)
 
void validateFileOpened (int opened, char *fn, const char *caller)
 
void validateHamilFileCoeffParsed (int parsed, PauliHamil h, FILE *file, char *fn, const char *caller)
 
void validateHamilFileParams (int numQubits, int numTerms, FILE *file, char *fn, const char *caller)
 
void validateHamilFilePauliCode (enum pauliOpType code, PauliHamil h, FILE *file, char *fn, const char *caller)
 
void validateHamilFilePauliParsed (int parsed, PauliHamil h, FILE *file, char *fn, const char *caller)
 
void validateHamilParams (int numQubits, int numTerms, const char *caller)
 
void validateMatchingQuregDims (Qureg qureg1, Qureg qureg2, const char *caller)
 
void validateMatchingQuregPauliHamilDims (Qureg qureg, PauliHamil hamil, const char *caller)
 
void validateMatchingQuregTypes (Qureg qureg1, Qureg qureg2, const char *caller)
 
void validateMatrixInit (ComplexMatrixN matr, const char *caller)
 
void validateMeasurementProb (qreal prob, const char *caller)
 
void validateMultiControls (Qureg qureg, int *controlQubits, int numControlQubits, const char *caller)
 
void validateMultiControlsMultiTargets (Qureg qureg, int *controlQubits, int numControlQubits, int *targetQubits, int numTargetQubits, const char *caller)
 
void validateMultiControlsTarget (Qureg qureg, int *controlQubits, int numControlQubits, int targetQubit, const char *caller)
 
void validateMultiQubitKrausMap (Qureg qureg, int numTargs, ComplexMatrixN *ops, int numOps, const char *caller)
 
void validateMultiQubitMatrix (Qureg qureg, ComplexMatrixN u, int numTargs, const char *caller)
 
void validateMultiQubitMatrixFitsInNode (Qureg qureg, int numTargets, const char *caller)
 
void validateMultiQubits (Qureg qureg, int *qubits, int numQubits, const char *caller)
 
void validateMultiQubitUnitaryMatrix (Qureg qureg, ComplexMatrixN u, int numTargs, const char *caller)
 
void validateMultiRegBitEncoding (int *numQubitsPerReg, int numRegs, enum bitEncoding encoding, const char *caller)
 
void validateMultiTargets (Qureg qureg, int *targetQubits, int numTargetQubits, const char *caller)
 
void validateMultiVarPhaseFuncOverrides (int *numQubitsPerReg, const int numRegs, enum bitEncoding encoding, long long int *overrideInds, int numOverrides, const char *caller)
 
void validateMultiVarPhaseFuncTerms (int *numQubitsPerReg, int numRegs, enum bitEncoding encoding, qreal *exponents, int *numTermsPerReg, const char *caller)
 
void validateNormProbs (qreal prob1, qreal prob2, const char *caller)
 
void validateNumAmps (Qureg qureg, long long int startInd, long long int numAmps, const char *caller)
 
void validateNumControls (Qureg qureg, int numControlQubits, const char *caller)
 
void validateNumElems (DiagonalOp op, long long int startInd, long long int numElems, const char *caller)
 
void validateNumPauliSumTerms (int numTerms, const char *caller)
 
void validateNumQubitsInDiagOp (int numQubits, int numRanks, const char *caller)
 
void validateNumQubitsInMatrix (int numQubits, const char *caller)
 
void validateNumQubitsInQureg (int numQubits, int numRanks, const char *caller)
 
void validateNumRanks (int numRanks, const char *caller)
 
void validateNumTargets (Qureg qureg, int numTargetQubits, const char *caller)
 
void validateOneQubitDampingProb (qreal prob, const char *caller)
 
void validateOneQubitDephaseProb (qreal prob, const char *caller)
 
void validateOneQubitDepolProb (qreal prob, const char *caller)
 
void validateOneQubitKrausMap (Qureg qureg, ComplexMatrix2 *ops, int numOps, const char *caller)
 
void validateOneQubitPauliProbs (qreal probX, qreal probY, qreal probZ, const char *caller)
 
void validateOneQubitUnitaryMatrix (ComplexMatrix2 u, const char *caller)
 
void validateOutcome (int outcome, const char *caller)
 
void validatePauliCodes (enum pauliOpType *pauliCodes, int numPauliCodes, const char *caller)
 
void validatePauliHamil (PauliHamil hamil, const char *caller)
 
void validatePhaseFuncName (enum phaseFunc funcCode, int numRegs, int numParams, const char *caller)
 
void validatePhaseFuncOverrides (const int numQubits, enum bitEncoding encoding, long long int *overrideInds, int numOverrides, const char *caller)
 
void validatePhaseFuncTerms (int numQubits, enum bitEncoding encoding, qreal *coeffs, qreal *exponents, int numTerms, long long int *overrideInds, int numOverrides, const char *caller)
 
void validateProb (qreal prob, const char *caller)
 
void validateQubitSubregs (Qureg qureg, int *qubits, int *numQubitsPerReg, const int numRegs, const char *caller)
 
void validateSecondQuregStateVec (Qureg qureg2, const char *caller)
 
void validateStateIndex (Qureg qureg, long long int stateInd, const char *caller)
 
void validateStateVecQureg (Qureg qureg, const char *caller)
 
void validateTarget (Qureg qureg, int targetQubit, const char *caller)
 
void validateTrotterParams (int order, int reps, const char *caller)
 
void validateTwoQubitDephaseProb (qreal prob, const char *caller)
 
void validateTwoQubitDepolProb (qreal prob, const char *caller)
 
void validateTwoQubitKrausMap (Qureg qureg, ComplexMatrix4 *ops, int numOps, const char *caller)
 
void validateTwoQubitUnitaryMatrix (Qureg qureg, ComplexMatrix4 u, const char *caller)
 
void validateUniqueTargets (Qureg qureg, int qubit1, int qubit2, const char *caller)
 
void validateUnitaryComplexPair (Complex alpha, Complex beta, const char *caller)
 
void validateVector (Vector vec, const char *caller)
 

Variables

char errMsgBuffer [1024]
 
static const char * errorMessages []
 

Detailed Description

Provides validation of user input

Author
Tyson Jones
Ania Brown (exitWithError(), QuESTAssert(), original testing of: qubit indices, unitarity, valid collapse probability)
Balint Koczor (Kraus maps)
Nicolas Vogt of HQS (one-qubit damping)

Definition in file QuEST_validation.c.

Macro Definition Documentation

◆ macro_isCompletelyPositiveMap

#define macro_isCompletelyPositiveMap (   ops,
  numOps,
  opDim 
)
Value:
{ \
for (int r=0; r<(opDim); r++) { \
for (int c=0; c<(opDim); c++) { \
qreal elemRe_ = 0; \
qreal elemIm_ = 0; \
for (int n=0; n<(numOps); n++) { \
for (int k=0; k<(opDim); k++) { \
elemRe_ += ops[n].real[k][r]*ops[n].real[k][c] + ops[n].imag[k][r]*ops[n].imag[k][c]; \
elemIm_ += ops[n].real[k][r]*ops[n].imag[k][c] - ops[n].imag[k][r]*ops[n].real[k][c]; \
} \
} \
qreal dist_ = absReal(elemIm_) + absReal(elemRe_ - ((r==c)? 1:0)); \
if (dist_ > REAL_EPS) \
return 0; \
} \
} \
return 1; \
}

Definition at line 282 of file QuEST_validation.c.

◆ macro_isMatrixUnitary

#define macro_isMatrixUnitary (   m,
  dim,
  retVal 
)
Value:
{ \
/* elemRe_ and elemIm_ must not exist in caller scope */ \
qreal elemRe_, elemIm_; \
retVal = 1; \
/* check m * ConjugateTranspose(m) == Identity */ \
for (int r=0; r < (dim); r++) { \
for (int c=0; c < (dim); c++) { \
/* m[r][...] * ConjugateTranspose(m)[...][c] */ \
elemRe_ = 0; \
elemIm_ = 0; \
for (int i=0; i < (dim); i++) { \
/* m[r][i] * conj(m[c][i]) */ \
elemRe_ += m.real[r][i]*m.real[c][i] + m.imag[r][i]*m.imag[c][i]; \
elemIm_ += m.imag[r][i]*m.real[c][i] - m.real[r][i]*m.imag[c][i]; \
} \
/* check distance from identity */ \
if ((absReal(elemIm_) > REAL_EPS) || \
(r == c && absReal(elemRe_ - 1) > REAL_EPS) || \
(r != c && absReal(elemRe_ ) > REAL_EPS)) { \
retVal = 0; \
break; \
} \
} \
if (retVal == 0) \
break; \
} \
}

Definition at line 236 of file QuEST_validation.c.

Enumeration Type Documentation

◆ ErrorCode

enum ErrorCode
Enumerator
E_SUCCESS 
E_INVALID_NUM_RANKS 
E_INVALID_NUM_CREATE_QUBITS 
E_INVALID_QUBIT_INDEX 
E_INVALID_TARGET_QUBIT 
E_INVALID_CONTROL_QUBIT 
E_INVALID_STATE_INDEX 
E_INVALID_AMP_INDEX 
E_INVALID_ELEM_INDEX 
E_INVALID_NUM_AMPS 
E_INVALID_NUM_ELEMS 
E_INVALID_OFFSET_NUM_AMPS_QUREG 
E_INVALID_OFFSET_NUM_ELEMS_DIAG 
E_TARGET_IS_CONTROL 
E_TARGET_IN_CONTROLS 
E_CONTROL_TARGET_COLLISION 
E_QUBITS_NOT_UNIQUE 
E_TARGETS_NOT_UNIQUE 
E_CONTROLS_NOT_UNIQUE 
E_INVALID_NUM_QUBITS 
E_INVALID_NUM_TARGETS 
E_INVALID_NUM_CONTROLS 
E_NON_UNITARY_MATRIX 
E_NON_UNITARY_COMPLEX_PAIR 
E_ZERO_VECTOR 
E_SYS_TOO_BIG_TO_PRINT 
E_COLLAPSE_STATE_ZERO_PROB 
E_INVALID_QUBIT_OUTCOME 
E_CANNOT_OPEN_FILE 
E_SECOND_ARG_MUST_BE_STATEVEC 
E_MISMATCHING_QUREG_DIMENSIONS 
E_MISMATCHING_QUREG_TYPES 
E_DEFINED_ONLY_FOR_STATEVECS 
E_DEFINED_ONLY_FOR_DENSMATRS 
E_INVALID_PROB 
E_UNNORM_PROBS 
E_INVALID_ONE_QUBIT_DEPHASE_PROB 
E_INVALID_TWO_QUBIT_DEPHASE_PROB 
E_INVALID_ONE_QUBIT_DEPOL_PROB 
E_INVALID_TWO_QUBIT_DEPOL_PROB 
E_INVALID_ONE_QUBIT_PAULI_PROBS 
E_INVALID_CONTROLS_BIT_STATE 
E_INVALID_PAULI_CODE 
E_INVALID_NUM_SUM_TERMS 
E_CANNOT_FIT_MULTI_QUBIT_MATRIX 
E_INVALID_UNITARY_SIZE 
E_COMPLEX_MATRIX_NOT_INIT 
E_INVALID_NUM_ONE_QUBIT_KRAUS_OPS 
E_INVALID_NUM_TWO_QUBIT_KRAUS_OPS 
E_INVALID_NUM_N_QUBIT_KRAUS_OPS 
E_INVALID_KRAUS_OPS 
E_MISMATCHING_NUM_TARGS_KRAUS_SIZE 
E_DISTRIB_QUREG_TOO_SMALL 
E_DISTRIB_DIAG_OP_TOO_SMALL 
E_NUM_AMPS_EXCEED_TYPE 
E_INVALID_PAULI_HAMIL_PARAMS 
E_INVALID_PAULI_HAMIL_FILE_PARAMS 
E_CANNOT_PARSE_PAULI_HAMIL_FILE_COEFF 
E_CANNOT_PARSE_PAULI_HAMIL_FILE_PAULI 
E_INVALID_PAULI_HAMIL_FILE_PAULI_CODE 
E_MISMATCHING_PAULI_HAMIL_QUREG_NUM_QUBITS 
E_INVALID_TROTTER_ORDER 
E_INVALID_TROTTER_REPS 
E_MISMATCHING_QUREG_DIAGONAL_OP_SIZE 
E_DIAGONAL_OP_NOT_INITIALISED 
E_PAULI_HAMIL_NOT_DIAGONAL 
E_MISMATCHING_PAULI_HAMIL_DIAGONAL_OP_SIZE 
E_INVALID_NUM_SUBREGISTERS 
E_INVALID_NUM_PHASE_FUNC_TERMS 
E_INVALID_NUM_PHASE_FUNC_OVERRIDES 
E_INVALID_PHASE_FUNC_OVERRIDE_UNSIGNED_INDEX 
E_INVALID_PHASE_FUNC_OVERRIDE_TWOS_COMPLEMENT_INDEX 
E_INVALID_PHASE_FUNC_NAME 
E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS 
E_INVALID_BIT_ENCODING 
E_INVALID_NUM_QUBITS_TWOS_COMPLEMENT 
E_NEGATIVE_EXPONENT_WITHOUT_ZERO_OVERRIDE 
E_FRACTIONAL_EXPONENT_WITHOUT_NEG_OVERRIDE 
E_NEGATIVE_EXPONENT_MULTI_VAR 
E_FRACTIONAL_EXPONENT_MULTI_VAR 
E_INVALID_NUM_REGS_DISTANCE_PHASE_FUNC 

Definition at line 32 of file QuEST_validation.c.

32  {
33  E_SUCCESS=0,
34  E_INVALID_NUM_RANKS,
35  E_INVALID_NUM_CREATE_QUBITS,
36  E_INVALID_QUBIT_INDEX,
37  E_INVALID_TARGET_QUBIT,
38  E_INVALID_CONTROL_QUBIT,
39  E_INVALID_STATE_INDEX,
40  E_INVALID_AMP_INDEX,
41  E_INVALID_ELEM_INDEX,
42  E_INVALID_NUM_AMPS,
43  E_INVALID_NUM_ELEMS,
44  E_INVALID_OFFSET_NUM_AMPS_QUREG,
45  E_INVALID_OFFSET_NUM_ELEMS_DIAG,
46  E_TARGET_IS_CONTROL,
47  E_TARGET_IN_CONTROLS,
48  E_CONTROL_TARGET_COLLISION,
49  E_QUBITS_NOT_UNIQUE,
50  E_TARGETS_NOT_UNIQUE,
51  E_CONTROLS_NOT_UNIQUE,
52  E_INVALID_NUM_QUBITS,
53  E_INVALID_NUM_TARGETS,
54  E_INVALID_NUM_CONTROLS,
55  E_NON_UNITARY_MATRIX,
56  E_NON_UNITARY_COMPLEX_PAIR,
57  E_ZERO_VECTOR,
58  E_SYS_TOO_BIG_TO_PRINT,
59  E_COLLAPSE_STATE_ZERO_PROB,
60  E_INVALID_QUBIT_OUTCOME,
61  E_CANNOT_OPEN_FILE,
62  E_SECOND_ARG_MUST_BE_STATEVEC,
63  E_MISMATCHING_QUREG_DIMENSIONS,
64  E_MISMATCHING_QUREG_TYPES,
65  E_DEFINED_ONLY_FOR_STATEVECS,
66  E_DEFINED_ONLY_FOR_DENSMATRS,
67  E_INVALID_PROB,
68  E_UNNORM_PROBS,
69  E_INVALID_ONE_QUBIT_DEPHASE_PROB,
70  E_INVALID_TWO_QUBIT_DEPHASE_PROB,
71  E_INVALID_ONE_QUBIT_DEPOL_PROB,
72  E_INVALID_TWO_QUBIT_DEPOL_PROB,
73  E_INVALID_ONE_QUBIT_PAULI_PROBS,
74  E_INVALID_CONTROLS_BIT_STATE,
75  E_INVALID_PAULI_CODE,
76  E_INVALID_NUM_SUM_TERMS,
77  E_CANNOT_FIT_MULTI_QUBIT_MATRIX,
78  E_INVALID_UNITARY_SIZE,
79  E_COMPLEX_MATRIX_NOT_INIT,
80  E_INVALID_NUM_ONE_QUBIT_KRAUS_OPS,
81  E_INVALID_NUM_TWO_QUBIT_KRAUS_OPS,
82  E_INVALID_NUM_N_QUBIT_KRAUS_OPS,
83  E_INVALID_KRAUS_OPS,
84  E_MISMATCHING_NUM_TARGS_KRAUS_SIZE,
85  E_DISTRIB_QUREG_TOO_SMALL,
86  E_DISTRIB_DIAG_OP_TOO_SMALL,
87  E_NUM_AMPS_EXCEED_TYPE,
88  E_INVALID_PAULI_HAMIL_PARAMS,
89  E_INVALID_PAULI_HAMIL_FILE_PARAMS,
90  E_CANNOT_PARSE_PAULI_HAMIL_FILE_COEFF,
91  E_CANNOT_PARSE_PAULI_HAMIL_FILE_PAULI,
92  E_INVALID_PAULI_HAMIL_FILE_PAULI_CODE,
93  E_MISMATCHING_PAULI_HAMIL_QUREG_NUM_QUBITS,
94  E_INVALID_TROTTER_ORDER,
95  E_INVALID_TROTTER_REPS,
96  E_MISMATCHING_QUREG_DIAGONAL_OP_SIZE,
97  E_DIAGONAL_OP_NOT_INITIALISED,
98  E_PAULI_HAMIL_NOT_DIAGONAL,
99  E_MISMATCHING_PAULI_HAMIL_DIAGONAL_OP_SIZE,
100  E_INVALID_NUM_SUBREGISTERS,
101  E_INVALID_NUM_PHASE_FUNC_TERMS,
102  E_INVALID_NUM_PHASE_FUNC_OVERRIDES,
103  E_INVALID_PHASE_FUNC_OVERRIDE_UNSIGNED_INDEX,
104  E_INVALID_PHASE_FUNC_OVERRIDE_TWOS_COMPLEMENT_INDEX,
105  E_INVALID_PHASE_FUNC_NAME,
106  E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS,
107  E_INVALID_BIT_ENCODING,
108  E_INVALID_NUM_QUBITS_TWOS_COMPLEMENT,
109  E_NEGATIVE_EXPONENT_WITHOUT_ZERO_OVERRIDE,
110  E_FRACTIONAL_EXPONENT_WITHOUT_NEG_OVERRIDE,
111  E_NEGATIVE_EXPONENT_MULTI_VAR,
112  E_FRACTIONAL_EXPONENT_MULTI_VAR,
113  E_INVALID_NUM_REGS_DISTANCE_PHASE_FUNC
114 } ErrorCode;

Function Documentation

◆ areUniqueQubits()

int areUniqueQubits ( int *  qubits,
int  numQubits 
)

Definition at line 315 of file QuEST_validation.c.

315  {
316  long long int mask = 0;
317  long long int bit;
318  for (int q=0; q < numQubits; q++) {
319  bit = 1LL << qubits[q];
320  if (mask & bit)
321  return 0;
322  mask |= bit;
323  }
324  return 1;
325 }

Referenced by validateMultiControls(), validateMultiQubits(), validateMultiTargets(), and validateQubitSubregs().

◆ default_invalidQuESTInputError()

void default_invalidQuESTInputError ( const char *  errMsg,
const char *  errFunc 
)

Definition at line 199 of file QuEST_validation.c.

199  {
200  printf("!!!\n");
201  printf("QuEST Error in function %s: %s\n", errFunc, errMsg);
202  printf("!!!\n");
203  printf("exiting..\n");
204  exit(1);
205 }

Referenced by invalidQuESTInputError().

◆ isCompletelyPositiveMap2()

int isCompletelyPositiveMap2 ( ComplexMatrix2 *  ops,
int  numOps 
)

Definition at line 300 of file QuEST_validation.c.

300  {
301  macro_isCompletelyPositiveMap(ops, numOps, 2);
302 }

References macro_isCompletelyPositiveMap.

Referenced by validateOneQubitKrausMap().

◆ isCompletelyPositiveMap4()

int isCompletelyPositiveMap4 ( ComplexMatrix4 *  ops,
int  numOps 
)

Definition at line 303 of file QuEST_validation.c.

303  {
304  macro_isCompletelyPositiveMap(ops, numOps, 4);
305 }

References macro_isCompletelyPositiveMap.

Referenced by validateTwoQubitKrausMap().

◆ isCompletelyPositiveMapN()

int isCompletelyPositiveMapN ( ComplexMatrixN *  ops,
int  numOps 
)

Definition at line 306 of file QuEST_validation.c.

306  {
307  int opDim = 1 << ops[0].numQubits;
308  macro_isCompletelyPositiveMap(ops, numOps, opDim);
309 }

References macro_isCompletelyPositiveMap, and ComplexMatrixN::numQubits.

Referenced by validateMultiQubitKrausMap().

◆ isComplexPairUnitary()

int isComplexPairUnitary ( Complex  alpha,
Complex  beta 
)

Definition at line 228 of file QuEST_validation.c.

228  {
229  return ( absReal( -1
230  + alpha.real*alpha.real
231  + alpha.imag*alpha.imag
232  + beta.real*beta.real
233  + beta.imag*beta.imag) < REAL_EPS );
234 }

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

Referenced by validateUnitaryComplexPair().

◆ isComplexUnit()

int isComplexUnit ( Complex  alpha)

Definition at line 220 of file QuEST_validation.c.

220  {
221  return (absReal(1 - sqrt(alpha.real*alpha.real + alpha.imag*alpha.imag)) < REAL_EPS);
222 }

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

◆ isMatrix2Unitary()

int isMatrix2Unitary ( ComplexMatrix2  u)

Definition at line 263 of file QuEST_validation.c.

263  {
264  int dim = 2;
265  int retVal;
266  macro_isMatrixUnitary(u, dim, retVal);
267  return retVal;
268 }

References macro_isMatrixUnitary.

Referenced by validateOneQubitUnitaryMatrix().

◆ isMatrix4Unitary()

int isMatrix4Unitary ( ComplexMatrix4  u)

Definition at line 269 of file QuEST_validation.c.

269  {
270  int dim = 4;
271  int retVal;
272  macro_isMatrixUnitary(u, dim, retVal);
273  return retVal;
274 }

References macro_isMatrixUnitary.

Referenced by validateTwoQubitUnitaryMatrix().

◆ isMatrixNUnitary()

int isMatrixNUnitary ( ComplexMatrixN  u)

Definition at line 275 of file QuEST_validation.c.

275  {
276  int dim = 1 << u.numQubits;
277  int retVal;
278  macro_isMatrixUnitary(u, dim, retVal);
279  return retVal;
280 }

References macro_isMatrixUnitary, and ComplexMatrixN::numQubits.

Referenced by validateMultiQubitUnitaryMatrix().

◆ isValidPauliCode()

int isValidPauliCode ( enum pauliOpType  code)

Definition at line 311 of file QuEST_validation.c.

311  {
312  return (code==PAULI_I || code==PAULI_X || code==PAULI_Y || code==PAULI_Z);
313 }

References PAULI_I, PAULI_X, PAULI_Y, and PAULI_Z.

Referenced by validateHamilFilePauliCode(), and validatePauliCodes().

◆ isVectorUnit()

int isVectorUnit ( qreal  ux,
qreal  uy,
qreal  uz 
)

Definition at line 224 of file QuEST_validation.c.

224  {
225  return (absReal(1 - sqrt(ux*ux + uy*uy + uz*uz)) < REAL_EPS );
226 }

◆ QuESTAssert()

void QuESTAssert ( int  isValid,
ErrorCode  code,
const char *  func 
)

Definition at line 216 of file QuEST_validation.c.

216  {
217  if (!isValid) invalidQuESTInputError(errorMessages[code], func);
218 }

References errorMessages, and invalidQuESTInputError().

Referenced by validateAmpIndex(), validateBitEncoding(), validateControl(), validateControlState(), validateControlTarget(), validateDensityMatrQureg(), validateDiagonalOp(), validateDiagOpInit(), validateDiagPauliHamil(), validateDiagPauliHamilFromFile(), validateHamilParams(), validateMatchingQuregDims(), validateMatchingQuregPauliHamilDims(), validateMatchingQuregTypes(), validateMatrixInit(), validateMeasurementProb(), validateMultiControls(), validateMultiControlsMultiTargets(), validateMultiControlsTarget(), validateMultiQubitKrausMap(), validateMultiQubitMatrix(), validateMultiQubitMatrixFitsInNode(), validateMultiQubits(), validateMultiQubitUnitaryMatrix(), validateMultiRegBitEncoding(), validateMultiTargets(), validateMultiVarPhaseFuncOverrides(), validateMultiVarPhaseFuncTerms(), validateNormProbs(), validateNumAmps(), validateNumControls(), validateNumElems(), validateNumPauliSumTerms(), validateNumQubitsInDiagOp(), validateNumQubitsInMatrix(), validateNumQubitsInQureg(), validateNumRanks(), validateNumTargets(), validateOneQubitDampingProb(), validateOneQubitDephaseProb(), validateOneQubitDepolProb(), validateOneQubitKrausMap(), validateOneQubitPauliProbs(), validateOneQubitUnitaryMatrix(), validateOutcome(), validatePauliCodes(), validatePhaseFuncName(), validatePhaseFuncOverrides(), validatePhaseFuncTerms(), validateProb(), validateQubitSubregs(), validateSecondQuregStateVec(), validateStateIndex(), validateStateVecQureg(), validateTarget(), validateTrotterParams(), validateTwoQubitDephaseProb(), validateTwoQubitDepolProb(), validateTwoQubitKrausMap(), validateTwoQubitUnitaryMatrix(), validateUniqueTargets(), validateUnitaryComplexPair(), and validateVector().

◆ validateAmpIndex()

void validateAmpIndex ( Qureg  qureg,
long long int  ampInd,
const char *  caller 
)

Definition at line 382 of file QuEST_validation.c.

382  {
383  long long int indMax = 1LL << qureg.numQubitsRepresented;
384  QuESTAssert(ampInd>=0 && ampInd<indMax, E_INVALID_AMP_INDEX, caller);
385 }

References E_INVALID_AMP_INDEX, Qureg::numQubitsRepresented, and QuESTAssert().

Referenced by getAmp(), getDensityAmp(), getImagAmp(), getProbAmp(), getRealAmp(), and validateNumAmps().

◆ validateBitEncoding()

void validateBitEncoding ( int  numQubits,
enum bitEncoding  encoding,
const char *  caller 
)

Definition at line 966 of file QuEST_validation.c.

966  {
967  QuESTAssert(
968  encoding == UNSIGNED ||
969  encoding == TWOS_COMPLEMENT,
970  E_INVALID_BIT_ENCODING, caller);
971 
972  if (encoding == TWOS_COMPLEMENT)
973  QuESTAssert(numQubits > 1, E_INVALID_NUM_QUBITS_TWOS_COMPLEMENT, caller);
974 }

References E_INVALID_BIT_ENCODING, E_INVALID_NUM_QUBITS_TWOS_COMPLEMENT, QuESTAssert(), TWOS_COMPLEMENT, and UNSIGNED.

Referenced by applyPhaseFunc(), and applyPhaseFuncOverrides().

◆ validateControl()

void validateControl ( Qureg  qureg,
int  controlQubit,
const char *  caller 
)

Definition at line 404 of file QuEST_validation.c.

404  {
405  QuESTAssert(controlQubit>=0 && controlQubit<qureg.numQubitsRepresented, E_INVALID_CONTROL_QUBIT, caller);
406 }

References E_INVALID_CONTROL_QUBIT, Qureg::numQubitsRepresented, and QuESTAssert().

Referenced by validateControlTarget(), and validateMultiControls().

◆ validateControlState()

void validateControlState ( int *  controlState,
int  numControlQubits,
const char *  caller 
)

Definition at line 468 of file QuEST_validation.c.

468  {
469  for (int i=0; i < numControlQubits; i++)
470  QuESTAssert(controlState[i] == 0 || controlState[i] == 1, E_INVALID_CONTROLS_BIT_STATE, caller);
471 }

References E_INVALID_CONTROLS_BIT_STATE, and QuESTAssert().

Referenced by multiStateControlledUnitary().

◆ validateControlTarget()

void validateControlTarget ( Qureg  qureg,
int  controlQubit,
int  targetQubit,
const char *  caller 
)

Definition at line 408 of file QuEST_validation.c.

408  {
409  validateTarget(qureg, targetQubit, caller);
410  validateControl(qureg, controlQubit, caller);
411  QuESTAssert(controlQubit != targetQubit, E_TARGET_IS_CONTROL, caller);
412 }

References E_TARGET_IS_CONTROL, QuESTAssert(), validateControl(), and validateTarget().

Referenced by controlledCompactUnitary(), controlledNot(), controlledPauliY(), controlledPhaseFlip(), controlledPhaseShift(), controlledRotateAroundAxis(), controlledRotateX(), controlledRotateY(), controlledRotateZ(), and controlledUnitary().

◆ validateDensityMatrQureg()

void validateDensityMatrQureg ( Qureg  qureg,
const char *  caller 
)

Definition at line 519 of file QuEST_validation.c.

519  {
520  QuESTAssert(qureg.isDensityMatrix, E_DEFINED_ONLY_FOR_DENSMATRS, caller);
521 }

References E_DEFINED_ONLY_FOR_DENSMATRS, Qureg::isDensityMatrix, and QuESTAssert().

Referenced by calcDensityInnerProduct(), calcHilbertSchmidtDistance(), calcPurity(), getDensityAmp(), mixDamping(), mixDensityMatrix(), mixDephasing(), mixDepolarising(), mixKrausMap(), mixMultiQubitKrausMap(), mixPauli(), mixTwoQubitDephasing(), mixTwoQubitDepolarising(), and mixTwoQubitKrausMap().

◆ validateDiagonalOp()

void validateDiagonalOp ( Qureg  qureg,
DiagonalOp  op,
const char *  caller 
)

Definition at line 713 of file QuEST_validation.c.

713  {
714  validateDiagOpInit(op, caller);
715  QuESTAssert(qureg.numQubitsRepresented == op.numQubits, E_MISMATCHING_QUREG_DIAGONAL_OP_SIZE, caller);
716 }

References E_MISMATCHING_QUREG_DIAGONAL_OP_SIZE, DiagonalOp::numQubits, Qureg::numQubitsRepresented, QuESTAssert(), and validateDiagOpInit().

Referenced by applyDiagonalOp(), and calcExpecDiagonalOp().

◆ validateDiagOpInit()

void validateDiagOpInit ( DiagonalOp  op,
const char *  caller 
)

Definition at line 709 of file QuEST_validation.c.

709  {
710  QuESTAssert(op.real != NULL && op.imag != NULL, E_DIAGONAL_OP_NOT_INITIALISED, caller);
711 }

References E_DIAGONAL_OP_NOT_INITIALISED, DiagonalOp::imag, QuESTAssert(), and DiagonalOp::real.

Referenced by destroyDiagonalOp(), initDiagonalOp(), initDiagonalOpFromPauliHamil(), setDiagonalOpElems(), syncDiagonalOp(), and validateDiagonalOp().

◆ validateDiagPauliHamil()

void validateDiagPauliHamil ( DiagonalOp  op,
PauliHamil  hamil,
const char *  caller 
)

Definition at line 718 of file QuEST_validation.c.

718  {
719  QuESTAssert(op.numQubits == hamil.numQubits, E_MISMATCHING_PAULI_HAMIL_DIAGONAL_OP_SIZE, caller);
720 
721  for (int p=0; p<hamil.numSumTerms*hamil.numQubits; p++)
722  QuESTAssert(
723  hamil.pauliCodes[p] == PAULI_I || hamil.pauliCodes[p] == PAULI_Z,
724  E_PAULI_HAMIL_NOT_DIAGONAL, caller);
725 }

References E_MISMATCHING_PAULI_HAMIL_DIAGONAL_OP_SIZE, E_PAULI_HAMIL_NOT_DIAGONAL, PauliHamil::numQubits, DiagonalOp::numQubits, PauliHamil::numSumTerms, PAULI_I, PAULI_Z, PauliHamil::pauliCodes, and QuESTAssert().

Referenced by initDiagonalOpFromPauliHamil().

◆ validateDiagPauliHamilFromFile()

void validateDiagPauliHamilFromFile ( PauliHamil  hamil,
int  numRanks,
const char *  caller 
)

Definition at line 727 of file QuEST_validation.c.

727  {
728  // hamil itself already validated as general Pauli Hamiltonian
729 
730  // destroy hamil before raising exceptions if validation fails
731  int isValid;
732 
733  // mustn't be more elements than can fit in the type
734  unsigned int maxQubits = calcLog2(SIZE_MAX);
735  isValid = hamil.numQubits <= maxQubits;
736  if (!isValid)
737  destroyPauliHamil(hamil);
738  QuESTAssert(isValid, E_NUM_AMPS_EXCEED_TYPE, caller);
739 
740  // must be at least one amplitude per node
741  long unsigned int numElems = (1UL<<hamil.numQubits);
742  isValid = numElems >= numRanks;
743  if (!isValid)
744  destroyPauliHamil(hamil);
745  QuESTAssert(isValid, E_DISTRIB_DIAG_OP_TOO_SMALL, caller);
746 
747  // must contain only I and Z
748  for (int p=0; p<hamil.numSumTerms*hamil.numQubits; p++) {
749  isValid = hamil.pauliCodes[p] == PAULI_I || hamil.pauliCodes[p] == PAULI_Z;
750  if (!isValid)
751  destroyPauliHamil(hamil);
752 
753  QuESTAssert(isValid, E_PAULI_HAMIL_NOT_DIAGONAL, caller);
754  }
755 }

References calcLog2(), destroyPauliHamil(), E_DISTRIB_DIAG_OP_TOO_SMALL, E_NUM_AMPS_EXCEED_TYPE, E_PAULI_HAMIL_NOT_DIAGONAL, PauliHamil::numQubits, PauliHamil::numSumTerms, PAULI_I, PAULI_Z, PauliHamil::pauliCodes, and QuESTAssert().

Referenced by createDiagonalOpFromPauliHamilFile().

◆ validateFileOpened()

void validateFileOpened ( int  opened,
char *  fn,
const char *  caller 
)

Definition at line 543 of file QuEST_validation.c.

543  {
544  if (!opened) {
545 
546  sprintf(errMsgBuffer, errorMessages[E_CANNOT_OPEN_FILE], fn);
547  invalidQuESTInputError(errMsgBuffer, caller);
548  }
549 }

References E_CANNOT_OPEN_FILE, errMsgBuffer, errorMessages, and invalidQuESTInputError().

Referenced by createPauliHamilFromFile(), initStateFromSingleFile(), and writeRecordedQASMToFile().

◆ validateHamilFileCoeffParsed()

void validateHamilFileCoeffParsed ( int  parsed,
PauliHamil  h,
FILE *  file,
char *  fn,
const char *  caller 
)

Definition at line 673 of file QuEST_validation.c.

673  {
674  if (!parsed) {
675  destroyPauliHamil(h);
676  fclose(file);
677 
678  sprintf(errMsgBuffer, errorMessages[E_CANNOT_PARSE_PAULI_HAMIL_FILE_COEFF], fn);
679  invalidQuESTInputError(errMsgBuffer, caller);
680  }
681 }

References destroyPauliHamil(), E_CANNOT_PARSE_PAULI_HAMIL_FILE_COEFF, errMsgBuffer, errorMessages, and invalidQuESTInputError().

Referenced by createPauliHamilFromFile().

◆ validateHamilFileParams()

void validateHamilFileParams ( int  numQubits,
int  numTerms,
FILE *  file,
char *  fn,
const char *  caller 
)

Definition at line 664 of file QuEST_validation.c.

664  {
665  if (!(numQubits > 0 && numTerms > 0)) {
666  fclose(file);
667 
668  sprintf(errMsgBuffer, errorMessages[E_INVALID_PAULI_HAMIL_FILE_PARAMS], fn);
669  invalidQuESTInputError(errMsgBuffer, caller);
670  }
671 }

References E_INVALID_PAULI_HAMIL_FILE_PARAMS, errMsgBuffer, errorMessages, and invalidQuESTInputError().

Referenced by createPauliHamilFromFile().

◆ validateHamilFilePauliCode()

void validateHamilFilePauliCode ( enum pauliOpType  code,
PauliHamil  h,
FILE *  file,
char *  fn,
const char *  caller 
)

Definition at line 693 of file QuEST_validation.c.

693  {
694  if (!isValidPauliCode(code)) {
695  destroyPauliHamil(h);
696  fclose(file);
697 
698  sprintf(errMsgBuffer, errorMessages[E_INVALID_PAULI_HAMIL_FILE_PAULI_CODE], fn, code);
699  invalidQuESTInputError(errMsgBuffer, caller);
700  }
701 }

References destroyPauliHamil(), E_INVALID_PAULI_HAMIL_FILE_PAULI_CODE, errMsgBuffer, errorMessages, invalidQuESTInputError(), and isValidPauliCode().

Referenced by createPauliHamilFromFile().

◆ validateHamilFilePauliParsed()

void validateHamilFilePauliParsed ( int  parsed,
PauliHamil  h,
FILE *  file,
char *  fn,
const char *  caller 
)

Definition at line 683 of file QuEST_validation.c.

683  {
684  if (!parsed) {
685  destroyPauliHamil(h);
686  fclose(file);
687 
688  sprintf(errMsgBuffer, errorMessages[E_CANNOT_PARSE_PAULI_HAMIL_FILE_PAULI], fn);
689  invalidQuESTInputError(errMsgBuffer, caller);
690  }
691 }

References destroyPauliHamil(), E_CANNOT_PARSE_PAULI_HAMIL_FILE_PAULI, errMsgBuffer, errorMessages, and invalidQuESTInputError().

Referenced by createPauliHamilFromFile().

◆ validateHamilParams()

void validateHamilParams ( int  numQubits,
int  numTerms,
const char *  caller 
)

Definition at line 651 of file QuEST_validation.c.

651  {
652  QuESTAssert(numQubits > 0 && numTerms > 0, E_INVALID_PAULI_HAMIL_PARAMS, caller);
653 }

References E_INVALID_PAULI_HAMIL_PARAMS, and QuESTAssert().

Referenced by createPauliHamil(), initDiagonalOpFromPauliHamil(), initPauliHamil(), and validatePauliHamil().

◆ validateMatchingQuregDims()

void validateMatchingQuregDims ( Qureg  qureg1,
Qureg  qureg2,
const char *  caller 
)

Definition at line 531 of file QuEST_validation.c.

531  {
532  QuESTAssert(qureg1.numQubitsRepresented==qureg2.numQubitsRepresented, E_MISMATCHING_QUREG_DIMENSIONS, caller);
533 }

References E_MISMATCHING_QUREG_DIMENSIONS, Qureg::numQubitsRepresented, and QuESTAssert().

Referenced by applyPauliHamil(), applyPauliSum(), calcDensityInnerProduct(), calcExpecPauliHamil(), calcExpecPauliProd(), calcExpecPauliSum(), calcFidelity(), calcHilbertSchmidtDistance(), calcInnerProduct(), cloneQureg(), compareStates(), initPureState(), mixDensityMatrix(), and setWeightedQureg().

◆ validateMatchingQuregPauliHamilDims()

void validateMatchingQuregPauliHamilDims ( Qureg  qureg,
PauliHamil  hamil,
const char *  caller 
)

Definition at line 660 of file QuEST_validation.c.

660  {
661  QuESTAssert(hamil.numQubits == qureg.numQubitsRepresented, E_MISMATCHING_PAULI_HAMIL_QUREG_NUM_QUBITS, caller);
662 }

References E_MISMATCHING_PAULI_HAMIL_QUREG_NUM_QUBITS, PauliHamil::numQubits, Qureg::numQubitsRepresented, and QuESTAssert().

Referenced by applyPauliHamil(), applyTrotterCircuit(), and calcExpecPauliHamil().

◆ validateMatchingQuregTypes()

void validateMatchingQuregTypes ( Qureg  qureg1,
Qureg  qureg2,
const char *  caller 
)

Definition at line 535 of file QuEST_validation.c.

535  {
536  QuESTAssert(qureg1.isDensityMatrix==qureg2.isDensityMatrix, E_MISMATCHING_QUREG_TYPES, caller);
537 }

References E_MISMATCHING_QUREG_TYPES, Qureg::isDensityMatrix, and QuESTAssert().

Referenced by applyPauliHamil(), applyPauliSum(), calcExpecPauliHamil(), calcExpecPauliProd(), calcExpecPauliSum(), cloneQureg(), and setWeightedQureg().

◆ validateMatrixInit()

void validateMatrixInit ( ComplexMatrixN  matr,
const char *  caller 
)

Definition at line 486 of file QuEST_validation.c.

486  {
487 
488  /* note that for (most) compilers which don't automatically initialise
489  * pointers to NULL, this can only be used to check the mallocs in createComplexMatrixN
490  * succeeded. It can not be used to differentiate whether a user actually attempted
491  * to initialise or create their ComplexMatrixN instance.
492  */
493  QuESTAssert(matr.real != NULL && matr.imag != NULL, E_COMPLEX_MATRIX_NOT_INIT, caller);
494 }

References E_COMPLEX_MATRIX_NOT_INIT, ComplexMatrixN::imag, QuESTAssert(), and ComplexMatrixN::real.

Referenced by createComplexMatrixN(), destroyComplexMatrixN(), initComplexMatrixN(), validateMultiQubitKrausMap(), and validateMultiQubitMatrix().

◆ validateMeasurementProb()

void validateMeasurementProb ( qreal  prob,
const char *  caller 
)

Definition at line 527 of file QuEST_validation.c.

527  {
528  QuESTAssert(prob>REAL_EPS, E_COLLAPSE_STATE_ZERO_PROB, caller);
529 }

References E_COLLAPSE_STATE_ZERO_PROB, and QuESTAssert().

Referenced by collapseToOutcome().

◆ validateMultiControls()

void validateMultiControls ( Qureg  qureg,
int *  controlQubits,
int  numControlQubits,
const char *  caller 
)

Definition at line 436 of file QuEST_validation.c.

436  {
437  validateNumControls(qureg, numControlQubits, caller);
438  for (int i=0; i < numControlQubits; i++)
439  validateControl(qureg, controlQubits[i], caller);
440 
441  QuESTAssert(areUniqueQubits(controlQubits, numControlQubits), E_CONTROLS_NOT_UNIQUE, caller);
442 }

References areUniqueQubits(), E_CONTROLS_NOT_UNIQUE, QuESTAssert(), validateControl(), and validateNumControls().

Referenced by validateMultiControlsMultiTargets(), and validateMultiControlsTarget().

◆ validateMultiControlsMultiTargets()

void validateMultiControlsMultiTargets ( Qureg  qureg,
int *  controlQubits,
int  numControlQubits,
int *  targetQubits,
int  numTargetQubits,
const char *  caller 
)

Definition at line 459 of file QuEST_validation.c.

459  {
460  validateMultiControls(qureg, controlQubits, numControlQubits, caller);
461  validateMultiTargets(qureg, targetQubits, numTargetQubits, caller);
462  long long int ctrlMask = getQubitBitMask(controlQubits, numControlQubits);
463  long long int targMask = getQubitBitMask(targetQubits, numTargetQubits);
464  int overlap = ctrlMask & targMask;
465  QuESTAssert(!overlap, E_CONTROL_TARGET_COLLISION, caller);
466 }

References E_CONTROL_TARGET_COLLISION, getQubitBitMask(), QuESTAssert(), validateMultiControls(), and validateMultiTargets().

Referenced by applyMultiControlledMatrixN(), controlledMultiQubitUnitary(), controlledTwoQubitUnitary(), multiControlledMultiQubitNot(), multiControlledMultiQubitUnitary(), multiControlledMultiRotatePauli(), multiControlledMultiRotateZ(), and multiControlledTwoQubitUnitary().

◆ validateMultiControlsTarget()

void validateMultiControlsTarget ( Qureg  qureg,
int *  controlQubits,
int  numControlQubits,
int  targetQubit,
const char *  caller 
)

Definition at line 452 of file QuEST_validation.c.

452  {
453  validateTarget(qureg, targetQubit, caller);
454  validateMultiControls(qureg, controlQubits, numControlQubits, caller);
455  for (int i=0; i < numControlQubits; i++)
456  QuESTAssert(controlQubits[i] != targetQubit, E_TARGET_IN_CONTROLS, caller);
457 }

References E_TARGET_IN_CONTROLS, QuESTAssert(), validateMultiControls(), and validateTarget().

Referenced by multiControlledUnitary(), and multiStateControlledUnitary().

◆ validateMultiQubitKrausMap()

void validateMultiQubitKrausMap ( Qureg  qureg,
int  numTargs,
ComplexMatrixN *  ops,
int  numOps,
const char *  caller 
)

Definition at line 634 of file QuEST_validation.c.

634  {
635  int opNumQubits = numTargs;
636  int superOpNumQubits = 2*opNumQubits;
637  int maxNumOps = superOpNumQubits*superOpNumQubits;
638  QuESTAssert(numOps>0 && numOps <= maxNumOps, E_INVALID_NUM_N_QUBIT_KRAUS_OPS, caller);
639 
640  for (int n=0; n<numOps; n++) {
641  validateMatrixInit(ops[n], __func__);
642  QuESTAssert(ops[n].numQubits == numTargs, E_MISMATCHING_NUM_TARGS_KRAUS_SIZE, caller);
643  }
644 
645  validateMultiQubitMatrixFitsInNode(qureg, superOpNumQubits, caller);
646 
647  int isPos = isCompletelyPositiveMapN(ops, numOps);
648  QuESTAssert(isPos, E_INVALID_KRAUS_OPS, caller);
649 }

References E_INVALID_KRAUS_OPS, E_INVALID_NUM_N_QUBIT_KRAUS_OPS, E_MISMATCHING_NUM_TARGS_KRAUS_SIZE, isCompletelyPositiveMapN(), QuESTAssert(), validateMatrixInit(), and validateMultiQubitMatrixFitsInNode().

Referenced by mixMultiQubitKrausMap().

◆ validateMultiQubitMatrix()

void validateMultiQubitMatrix ( Qureg  qureg,
ComplexMatrixN  u,
int  numTargs,
const char *  caller 
)

Definition at line 496 of file QuEST_validation.c.

496  {
497  validateMatrixInit(u, caller);
498  validateMultiQubitMatrixFitsInNode(qureg, numTargs, caller);
499  QuESTAssert(numTargs == u.numQubits, E_INVALID_UNITARY_SIZE, caller);
500 }

References E_INVALID_UNITARY_SIZE, ComplexMatrixN::numQubits, QuESTAssert(), validateMatrixInit(), and validateMultiQubitMatrixFitsInNode().

Referenced by applyMatrixN(), applyMultiControlledMatrixN(), and validateMultiQubitUnitaryMatrix().

◆ validateMultiQubitMatrixFitsInNode()

void validateMultiQubitMatrixFitsInNode ( Qureg  qureg,
int  numTargets,
const char *  caller 
)

Definition at line 473 of file QuEST_validation.c.

473  {
474  QuESTAssert(qureg.numAmpsPerChunk >= (1LL << numTargets), E_CANNOT_FIT_MULTI_QUBIT_MATRIX, caller);
475 }

References E_CANNOT_FIT_MULTI_QUBIT_MATRIX, Qureg::numAmpsPerChunk, and QuESTAssert().

Referenced by applyMatrix4(), sqrtSwapGate(), validateMultiQubitKrausMap(), validateMultiQubitMatrix(), validateOneQubitKrausMap(), validateTwoQubitKrausMap(), and validateTwoQubitUnitaryMatrix().

◆ validateMultiQubits()

void validateMultiQubits ( Qureg  qureg,
int *  qubits,
int  numQubits,
const char *  caller 
)

Definition at line 444 of file QuEST_validation.c.

444  {
445  QuESTAssert(numQubits>0 && numQubits<=qureg.numQubitsRepresented, E_INVALID_NUM_QUBITS, caller);
446  for (int i=0; i < numQubits; i++)
447  QuESTAssert(qubits[i]>=0 && qubits[i]<qureg.numQubitsRepresented, E_INVALID_QUBIT_INDEX, caller);
448 
449  QuESTAssert(areUniqueQubits(qubits, numQubits), E_QUBITS_NOT_UNIQUE, caller);
450 }

References areUniqueQubits(), E_INVALID_NUM_QUBITS, E_INVALID_QUBIT_INDEX, E_QUBITS_NOT_UNIQUE, Qureg::numQubitsRepresented, and QuESTAssert().

Referenced by applyPhaseFunc(), applyPhaseFuncOverrides(), multiControlledPhaseFlip(), and multiControlledPhaseShift().

◆ validateMultiQubitUnitaryMatrix()

void validateMultiQubitUnitaryMatrix ( Qureg  qureg,
ComplexMatrixN  u,
int  numTargs,
const char *  caller 
)

Definition at line 502 of file QuEST_validation.c.

502  {
503  validateMultiQubitMatrix(qureg, u, numTargs, caller);
504  QuESTAssert(isMatrixNUnitary(u), E_NON_UNITARY_MATRIX, caller);
505 }

References E_NON_UNITARY_MATRIX, isMatrixNUnitary(), QuESTAssert(), and validateMultiQubitMatrix().

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

◆ validateMultiRegBitEncoding()

void validateMultiRegBitEncoding ( int *  numQubitsPerReg,
int  numRegs,
enum bitEncoding  encoding,
const char *  caller 
)

Definition at line 976 of file QuEST_validation.c.

976  {
977  QuESTAssert(
978  encoding == UNSIGNED ||
979  encoding == TWOS_COMPLEMENT,
980  E_INVALID_BIT_ENCODING, caller);
981 
982  if (encoding == TWOS_COMPLEMENT)
983  for (int r=0; r<numRegs; r++)
984  QuESTAssert(numQubitsPerReg[r] > 1, E_INVALID_NUM_QUBITS_TWOS_COMPLEMENT, caller);
985 }

References E_INVALID_BIT_ENCODING, E_INVALID_NUM_QUBITS_TWOS_COMPLEMENT, QuESTAssert(), TWOS_COMPLEMENT, and UNSIGNED.

Referenced by applyMultiVarPhaseFunc(), applyMultiVarPhaseFuncOverrides(), applyNamedPhaseFunc(), applyNamedPhaseFuncOverrides(), applyParamNamedPhaseFunc(), and applyParamNamedPhaseFuncOverrides().

◆ validateMultiTargets()

void validateMultiTargets ( Qureg  qureg,
int *  targetQubits,
int  numTargetQubits,
const char *  caller 
)

Definition at line 428 of file QuEST_validation.c.

428  {
429  validateNumTargets(qureg, numTargetQubits, caller);
430  for (int i=0; i < numTargetQubits; i++)
431  validateTarget(qureg, targetQubits[i], caller);
432 
433  QuESTAssert(areUniqueQubits(targetQubits, numTargetQubits), E_TARGETS_NOT_UNIQUE, caller);
434 }

References areUniqueQubits(), E_TARGETS_NOT_UNIQUE, QuESTAssert(), validateNumTargets(), and validateTarget().

Referenced by applyMatrix4(), applyMatrixN(), applyQFT(), calcExpecPauliProd(), calcProbOfAllOutcomes(), mixMultiQubitKrausMap(), mixTwoQubitKrausMap(), multiQubitNot(), multiQubitUnitary(), multiRotatePauli(), multiRotateZ(), twoQubitUnitary(), and validateMultiControlsMultiTargets().

◆ validateMultiVarPhaseFuncOverrides()

void validateMultiVarPhaseFuncOverrides ( int *  numQubitsPerReg,
const int  numRegs,
enum bitEncoding  encoding,
long long int *  overrideInds,
int  numOverrides,
const char *  caller 
)

Definition at line 886 of file QuEST_validation.c.

886  {
887  QuESTAssert(numOverrides>=0, E_INVALID_NUM_PHASE_FUNC_OVERRIDES, caller);
888 
889  if (encoding == UNSIGNED) {
890  int i=0;
891  for (int v=0; v<numOverrides; v++) {
892  for (int r=0; r<numRegs; r++) {
893  long long int maxInd = (1LL << numQubitsPerReg[r]) - 1;
894  QuESTAssert(overrideInds[i]>=0 && overrideInds[i]<=maxInd, E_INVALID_PHASE_FUNC_OVERRIDE_UNSIGNED_INDEX, caller);
895  i++;
896  }
897  }
898  }
899  else if (encoding == TWOS_COMPLEMENT) {
900  int i=0;
901  for (int v=0; v<numOverrides; v++) {
902  for (int r=0; r<numRegs; r++) {
903  int numValQubits = numQubitsPerReg[r] - 1; // removing sign bit
904  long long int minInd = - (1LL << numValQubits);
905  long long int maxInd = (1LL << numValQubits) - 1;
906  QuESTAssert(overrideInds[i]>=minInd && overrideInds[i]<=maxInd, E_INVALID_PHASE_FUNC_OVERRIDE_TWOS_COMPLEMENT_INDEX, caller);
907  i++;
908  }
909  }
910  }
911 }

References E_INVALID_NUM_PHASE_FUNC_OVERRIDES, E_INVALID_PHASE_FUNC_OVERRIDE_TWOS_COMPLEMENT_INDEX, E_INVALID_PHASE_FUNC_OVERRIDE_UNSIGNED_INDEX, QuESTAssert(), TWOS_COMPLEMENT, and UNSIGNED.

Referenced by applyMultiVarPhaseFuncOverrides(), applyNamedPhaseFuncOverrides(), and applyParamNamedPhaseFuncOverrides().

◆ validateMultiVarPhaseFuncTerms()

void validateMultiVarPhaseFuncTerms ( int *  numQubitsPerReg,
int  numRegs,
enum bitEncoding  encoding,
qreal *  exponents,
int *  numTermsPerReg,
const char *  caller 
)

Definition at line 836 of file QuEST_validation.c.

836  {
837  QuESTAssert(numRegs>0 && numRegs<=MAX_NUM_REGS_APPLY_ARBITRARY_PHASE, E_INVALID_NUM_SUBREGISTERS, caller);
838  for (int r=0; r<numRegs; r++)
839  QuESTAssert(numTermsPerReg[r]>0, E_INVALID_NUM_PHASE_FUNC_TERMS, caller);
840 
841  int numTotalTerms = 0;
842  for (int r=0; r<numRegs; r++)
843  numTotalTerms += numTermsPerReg[r];
844 
845  int hasFractionExpo = 0;
846  int hasNegativeExpo = 0;
847  for (int t=0; t<numTotalTerms; t++) {
848  // this is only true if exponent is precisely an integer, else pow() will NaN
849  if (floor(exponents[t]) != exponents[t])
850  hasFractionExpo = 1;
851  if (exponents[t] < 0)
852  hasNegativeExpo = 1;
853  }
854 
855  QuESTAssert(!hasNegativeExpo, E_NEGATIVE_EXPONENT_MULTI_VAR, caller);
856 
857  if (encoding == TWOS_COMPLEMENT)
858  QuESTAssert(!hasFractionExpo, E_FRACTIONAL_EXPONENT_MULTI_VAR, caller);
859 }

References E_FRACTIONAL_EXPONENT_MULTI_VAR, E_INVALID_NUM_PHASE_FUNC_TERMS, E_INVALID_NUM_SUBREGISTERS, E_NEGATIVE_EXPONENT_MULTI_VAR, MAX_NUM_REGS_APPLY_ARBITRARY_PHASE, QuESTAssert(), and TWOS_COMPLEMENT.

Referenced by applyMultiVarPhaseFunc(), and applyMultiVarPhaseFuncOverrides().

◆ validateNormProbs()

void validateNormProbs ( qreal  prob1,
qreal  prob2,
const char *  caller 
)

Definition at line 555 of file QuEST_validation.c.

555  {
556  validateProb(prob1, caller);
557  validateProb(prob2, caller);
558 
559  qreal sum = prob1 + prob2;
560  QuESTAssert(absReal(1 - sum) < REAL_EPS, E_UNNORM_PROBS, caller);
561 }

References E_UNNORM_PROBS, qreal, QuESTAssert(), and validateProb().

◆ validateNumAmps()

void validateNumAmps ( Qureg  qureg,
long long int  startInd,
long long int  numAmps,
const char *  caller 
)

Definition at line 387 of file QuEST_validation.c.

387  {
388  validateAmpIndex(qureg, startInd, caller);
389  QuESTAssert(numAmps >= 0 && numAmps <= qureg.numAmpsTotal, E_INVALID_NUM_AMPS, caller);
390  QuESTAssert(numAmps + startInd <= qureg.numAmpsTotal, E_INVALID_OFFSET_NUM_AMPS_QUREG, caller);
391 }

References E_INVALID_NUM_AMPS, E_INVALID_OFFSET_NUM_AMPS_QUREG, Qureg::numAmpsTotal, QuESTAssert(), and validateAmpIndex().

Referenced by setAmps().

◆ validateNumControls()

void validateNumControls ( Qureg  qureg,
int  numControlQubits,
const char *  caller 
)

Definition at line 424 of file QuEST_validation.c.

424  {
425  QuESTAssert(numControlQubits>0 && numControlQubits<qureg.numQubitsRepresented, E_INVALID_NUM_CONTROLS, caller);
426 }

References E_INVALID_NUM_CONTROLS, Qureg::numQubitsRepresented, and QuESTAssert().

Referenced by validateMultiControls().

◆ validateNumElems()

void validateNumElems ( DiagonalOp  op,
long long int  startInd,
long long int  numElems,
const char *  caller 
)

Definition at line 393 of file QuEST_validation.c.

393  {
394  long long int indMax = 1LL << op.numQubits;
395  QuESTAssert(startInd >= 0 && startInd < indMax, E_INVALID_ELEM_INDEX, caller);
396  QuESTAssert(numElems >= 0 && numElems <= indMax, E_INVALID_NUM_ELEMS, caller);
397  QuESTAssert(numElems + startInd <= indMax, E_INVALID_OFFSET_NUM_ELEMS_DIAG, caller);
398 }

References E_INVALID_ELEM_INDEX, E_INVALID_NUM_ELEMS, E_INVALID_OFFSET_NUM_ELEMS_DIAG, DiagonalOp::numQubits, and QuESTAssert().

Referenced by setDiagonalOpElems().

◆ validateNumPauliSumTerms()

void validateNumPauliSumTerms ( int  numTerms,
const char *  caller 
)

Definition at line 606 of file QuEST_validation.c.

606  {
607  QuESTAssert(numTerms > 0, E_INVALID_NUM_SUM_TERMS, caller);
608 }

References E_INVALID_NUM_SUM_TERMS, and QuESTAssert().

Referenced by applyPauliSum(), and calcExpecPauliSum().

◆ validateNumQubitsInDiagOp()

void validateNumQubitsInDiagOp ( int  numQubits,
int  numRanks,
const char *  caller 
)

Definition at line 365 of file QuEST_validation.c.

365  {
366  QuESTAssert(numQubits>0, E_INVALID_NUM_CREATE_QUBITS, caller);
367 
368  // mustn't be more amplitudes than can fit in the type
369  unsigned int maxQubits = calcLog2(SIZE_MAX);
370  QuESTAssert( numQubits <= maxQubits, E_NUM_AMPS_EXCEED_TYPE, caller);
371 
372  // must be at least one amplitude per node
373  long unsigned int numAmps = (1UL<<numQubits);
374  QuESTAssert(numAmps >= numRanks, E_DISTRIB_DIAG_OP_TOO_SMALL, caller);
375 }

References calcLog2(), E_DISTRIB_DIAG_OP_TOO_SMALL, E_INVALID_NUM_CREATE_QUBITS, E_NUM_AMPS_EXCEED_TYPE, and QuESTAssert().

Referenced by createDiagonalOp().

◆ validateNumQubitsInMatrix()

void validateNumQubitsInMatrix ( int  numQubits,
const char *  caller 
)

Definition at line 361 of file QuEST_validation.c.

361  {
362  QuESTAssert(numQubits>0, E_INVALID_NUM_QUBITS, caller);
363 }

References E_INVALID_NUM_QUBITS, and QuESTAssert().

Referenced by createComplexMatrixN().

◆ validateNumQubitsInQureg()

void validateNumQubitsInQureg ( int  numQubits,
int  numRanks,
const char *  caller 
)

Definition at line 349 of file QuEST_validation.c.

349  {
350  QuESTAssert(numQubits>0, E_INVALID_NUM_CREATE_QUBITS, caller);
351 
352  // mustn't be more amplitudes than can fit in the type
353  unsigned int maxQubits = calcLog2(SIZE_MAX);
354  QuESTAssert( numQubits <= maxQubits, E_NUM_AMPS_EXCEED_TYPE, caller);
355 
356  // must be at least one amplitude per node
357  long unsigned int numAmps = (1UL<<numQubits);
358  QuESTAssert(numAmps >= numRanks, E_DISTRIB_QUREG_TOO_SMALL, caller);
359 }

References calcLog2(), E_DISTRIB_QUREG_TOO_SMALL, E_INVALID_NUM_CREATE_QUBITS, E_NUM_AMPS_EXCEED_TYPE, and QuESTAssert().

Referenced by createDensityQureg(), and createQureg().

◆ validateNumRanks()

void validateNumRanks ( int  numRanks,
const char *  caller 
)

Definition at line 335 of file QuEST_validation.c.

335  {
336 
337  /* silly but robust way to determine if numRanks is a power of 2,
338  * in lieu of bit-twiddling (e.g. AND with all-ones) which may be
339  * system / precsision dependent
340  */
341  int isValid = 0;
342  for (int exp2 = 1; exp2 <= numRanks; exp2 *= 2)
343  if (exp2 == numRanks)
344  isValid = 1;
345 
346  QuESTAssert(isValid, E_INVALID_NUM_RANKS, caller);
347 }

References E_INVALID_NUM_RANKS, and QuESTAssert().

Referenced by createQuESTEnv().

◆ validateNumTargets()

void validateNumTargets ( Qureg  qureg,
int  numTargetQubits,
const char *  caller 
)

Definition at line 420 of file QuEST_validation.c.

420  {
421  QuESTAssert(numTargetQubits>0 && numTargetQubits<=qureg.numQubitsRepresented, E_INVALID_NUM_TARGETS, caller);
422 }

References E_INVALID_NUM_TARGETS, Qureg::numQubitsRepresented, and QuESTAssert().

Referenced by validateMultiTargets().

◆ validateOneQubitDampingProb()

void validateOneQubitDampingProb ( qreal  prob,
const char *  caller 
)

Definition at line 578 of file QuEST_validation.c.

578  {
579  validateProb(prob, caller);
580  QuESTAssert(prob <= 1.0, E_INVALID_ONE_QUBIT_DEPOL_PROB, caller);
581 }

References E_INVALID_ONE_QUBIT_DEPOL_PROB, QuESTAssert(), and validateProb().

Referenced by mixDamping().

◆ validateOneQubitDephaseProb()

void validateOneQubitDephaseProb ( qreal  prob,
const char *  caller 
)

Definition at line 563 of file QuEST_validation.c.

563  {
564  validateProb(prob, caller);
565  QuESTAssert(prob <= 1/2.0, E_INVALID_ONE_QUBIT_DEPHASE_PROB, caller);
566 }

References E_INVALID_ONE_QUBIT_DEPHASE_PROB, QuESTAssert(), and validateProb().

Referenced by mixDephasing().

◆ validateOneQubitDepolProb()

void validateOneQubitDepolProb ( qreal  prob,
const char *  caller 
)

Definition at line 573 of file QuEST_validation.c.

573  {
574  validateProb(prob, caller);
575  QuESTAssert(prob <= 3/4.0, E_INVALID_ONE_QUBIT_DEPOL_PROB, caller);
576 }

References E_INVALID_ONE_QUBIT_DEPOL_PROB, QuESTAssert(), and validateProb().

Referenced by mixDepolarising().

◆ validateOneQubitKrausMap()

void validateOneQubitKrausMap ( Qureg  qureg,
ComplexMatrix2 *  ops,
int  numOps,
const char *  caller 
)

Definition at line 610 of file QuEST_validation.c.

610  {
611  int opNumQubits = 1;
612  int superOpNumQubits = 2*opNumQubits;
613  int maxNumOps = superOpNumQubits*superOpNumQubits;
614  QuESTAssert(numOps > 0 && numOps <= maxNumOps, E_INVALID_NUM_ONE_QUBIT_KRAUS_OPS, caller);
615 
616  validateMultiQubitMatrixFitsInNode(qureg, superOpNumQubits, caller);
617 
618  int isPos = isCompletelyPositiveMap2(ops, numOps);
619  QuESTAssert(isPos, E_INVALID_KRAUS_OPS, caller);
620 }

References E_INVALID_KRAUS_OPS, E_INVALID_NUM_ONE_QUBIT_KRAUS_OPS, isCompletelyPositiveMap2(), QuESTAssert(), and validateMultiQubitMatrixFitsInNode().

Referenced by mixKrausMap().

◆ validateOneQubitPauliProbs()

void validateOneQubitPauliProbs ( qreal  probX,
qreal  probY,
qreal  probZ,
const char *  caller 
)

Definition at line 588 of file QuEST_validation.c.

588  {
589  validateProb(probX, caller);
590  validateProb(probY, caller);
591  validateProb(probZ, caller);
592 
593  qreal probNoError = 1 - probX - probY - probZ;
594  QuESTAssert(probX <= probNoError, E_INVALID_ONE_QUBIT_PAULI_PROBS, caller);
595  QuESTAssert(probY <= probNoError, E_INVALID_ONE_QUBIT_PAULI_PROBS, caller);
596  QuESTAssert(probZ <= probNoError, E_INVALID_ONE_QUBIT_PAULI_PROBS, caller);
597 }

References E_INVALID_ONE_QUBIT_PAULI_PROBS, qreal, QuESTAssert(), and validateProb().

Referenced by mixPauli().

◆ validateOneQubitUnitaryMatrix()

void validateOneQubitUnitaryMatrix ( ComplexMatrix2  u,
const char *  caller 
)

Definition at line 477 of file QuEST_validation.c.

477  {
478  QuESTAssert(isMatrix2Unitary(u), E_NON_UNITARY_MATRIX, caller);
479 }

References E_NON_UNITARY_MATRIX, isMatrix2Unitary(), and QuESTAssert().

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

◆ validateOutcome()

void validateOutcome ( int  outcome,
const char *  caller 
)

Definition at line 523 of file QuEST_validation.c.

523  {
524  QuESTAssert(outcome==0 || outcome==1, E_INVALID_QUBIT_OUTCOME, caller);
525 }

References E_INVALID_QUBIT_OUTCOME, and QuESTAssert().

Referenced by applyProjector(), calcProbOfOutcome(), collapseToOutcome(), and initStateOfSingleQubit().

◆ validatePauliCodes()

void validatePauliCodes ( enum pauliOpType *  pauliCodes,
int  numPauliCodes,
const char *  caller 
)

Definition at line 599 of file QuEST_validation.c.

599  {
600  for (int i=0; i < numPauliCodes; i++) {
601  enum pauliOpType code = pauliCodes[i];
602  QuESTAssert(isValidPauliCode(code), E_INVALID_PAULI_CODE, caller);
603  }
604 }

References E_INVALID_PAULI_CODE, isValidPauliCode(), and QuESTAssert().

Referenced by applyPauliSum(), calcExpecPauliProd(), calcExpecPauliSum(), initPauliHamil(), multiControlledMultiRotatePauli(), multiRotatePauli(), and validatePauliHamil().

◆ validatePauliHamil()

void validatePauliHamil ( PauliHamil  hamil,
const char *  caller 
)

Definition at line 655 of file QuEST_validation.c.

655  {
656  validateHamilParams(hamil.numQubits, hamil.numSumTerms, caller);
657  validatePauliCodes(hamil.pauliCodes, hamil.numSumTerms*hamil.numQubits, caller);
658 }

References PauliHamil::numQubits, PauliHamil::numSumTerms, PauliHamil::pauliCodes, validateHamilParams(), and validatePauliCodes().

Referenced by applyPauliHamil(), applyTrotterCircuit(), calcExpecPauliHamil(), and reportPauliHamil().

◆ validatePhaseFuncName()

void validatePhaseFuncName ( enum phaseFunc  funcCode,
int  numRegs,
int  numParams,
const char *  caller 
)

Definition at line 913 of file QuEST_validation.c.

913  {
914 
915  QuESTAssert(
916  funcCode == NORM ||
917  funcCode == INVERSE_NORM ||
918  funcCode == SCALED_NORM ||
919  funcCode == SCALED_INVERSE_NORM ||
920  funcCode == SCALED_INVERSE_SHIFTED_NORM ||
921  funcCode == PRODUCT ||
922  funcCode == INVERSE_PRODUCT ||
923  funcCode == SCALED_PRODUCT ||
924  funcCode == SCALED_INVERSE_PRODUCT ||
925  funcCode == DISTANCE ||
926  funcCode == INVERSE_DISTANCE ||
927  funcCode == SCALED_DISTANCE ||
928  funcCode == SCALED_INVERSE_DISTANCE ||
929  funcCode == SCALED_INVERSE_SHIFTED_DISTANCE,
930  E_INVALID_PHASE_FUNC_NAME, caller);
931 
932  if (funcCode == NORM ||
933  funcCode == PRODUCT ||
934  funcCode == DISTANCE)
935  QuESTAssert(numParams == 0, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, caller);
936 
937  if (funcCode == INVERSE_NORM ||
938  funcCode == INVERSE_PRODUCT ||
939  funcCode == INVERSE_DISTANCE)
940  QuESTAssert(numParams == 1, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, caller);
941 
942  if (funcCode == SCALED_NORM ||
943  funcCode == SCALED_PRODUCT ||
944  funcCode == SCALED_DISTANCE)
945  QuESTAssert(numParams == 1, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, caller);
946 
947  if (funcCode == SCALED_INVERSE_NORM ||
948  funcCode == SCALED_INVERSE_PRODUCT ||
949  funcCode == SCALED_INVERSE_DISTANCE)
950  QuESTAssert(numParams == 2, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, caller);
951 
952  if (funcCode == SCALED_INVERSE_SHIFTED_NORM)
953  QuESTAssert(numParams == 2 + numRegs, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, caller);
954 
955  if (funcCode == SCALED_INVERSE_SHIFTED_DISTANCE)
956  QuESTAssert(numParams == 2 + numRegs / 2, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, caller);
957 
958  if (funcCode == DISTANCE ||
959  funcCode == INVERSE_DISTANCE ||
960  funcCode == SCALED_DISTANCE ||
961  funcCode == SCALED_INVERSE_DISTANCE ||
962  funcCode == SCALED_INVERSE_SHIFTED_DISTANCE)
963  QuESTAssert(numRegs%2 == 0, E_INVALID_NUM_REGS_DISTANCE_PHASE_FUNC, caller);
964 }

References DISTANCE, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, E_INVALID_NUM_REGS_DISTANCE_PHASE_FUNC, E_INVALID_PHASE_FUNC_NAME, INVERSE_DISTANCE, INVERSE_NORM, INVERSE_PRODUCT, NORM, PRODUCT, QuESTAssert(), SCALED_DISTANCE, SCALED_INVERSE_DISTANCE, SCALED_INVERSE_NORM, SCALED_INVERSE_PRODUCT, SCALED_INVERSE_SHIFTED_DISTANCE, SCALED_INVERSE_SHIFTED_NORM, SCALED_NORM, and SCALED_PRODUCT.

Referenced by applyNamedPhaseFunc(), applyNamedPhaseFuncOverrides(), applyParamNamedPhaseFunc(), and applyParamNamedPhaseFuncOverrides().

◆ validatePhaseFuncOverrides()

void validatePhaseFuncOverrides ( const int  numQubits,
enum bitEncoding  encoding,
long long int *  overrideInds,
int  numOverrides,
const char *  caller 
)

Definition at line 862 of file QuEST_validation.c.

862  {
863  QuESTAssert(numOverrides>=0, E_INVALID_NUM_PHASE_FUNC_OVERRIDES, caller);
864  QuESTAssert(numOverrides<=(1<<numQubits), E_INVALID_NUM_PHASE_FUNC_OVERRIDES, caller);
865 
866  long long int maxInd;
867  long long int minInd;
868 
869  if (encoding == UNSIGNED) {
870  minInd = 0;
871  maxInd = (1LL << numQubits) - 1;
872  for (int v=0; v<numOverrides; v++)
873  QuESTAssert(overrideInds[v]>=minInd && overrideInds[v]<=maxInd, E_INVALID_PHASE_FUNC_OVERRIDE_UNSIGNED_INDEX, caller);
874  }
875 
876  if (encoding == TWOS_COMPLEMENT) {
877  int numValQubits = numQubits - 1; // removing sign bit
878  minInd = - (1LL << numValQubits);
879  maxInd = (1LL << numValQubits) - 1;
880  for (int v=0; v<numOverrides; v++)
881  QuESTAssert(overrideInds[v]>=minInd && overrideInds[v]<=maxInd, E_INVALID_PHASE_FUNC_OVERRIDE_TWOS_COMPLEMENT_INDEX, caller);
882  }
883 
884 }

References E_INVALID_NUM_PHASE_FUNC_OVERRIDES, E_INVALID_PHASE_FUNC_OVERRIDE_TWOS_COMPLEMENT_INDEX, E_INVALID_PHASE_FUNC_OVERRIDE_UNSIGNED_INDEX, QuESTAssert(), TWOS_COMPLEMENT, and UNSIGNED.

Referenced by applyPhaseFuncOverrides().

◆ validatePhaseFuncTerms()

void validatePhaseFuncTerms ( int  numQubits,
enum bitEncoding  encoding,
qreal *  coeffs,
qreal *  exponents,
int  numTerms,
long long int *  overrideInds,
int  numOverrides,
const char *  caller 
)

Definition at line 773 of file QuEST_validation.c.

773  {
774  QuESTAssert(numTerms>0, E_INVALID_NUM_PHASE_FUNC_TERMS, caller);
775 
776  int hasFractionExpo = 0;
777  int hasNegativeExpo = 0;
778  for (int t=0; t<numTerms; t++) {
779  // this is only true if exponent is precisely an integer, else pow() will NaN
780  if (floor(exponents[t]) != exponents[t])
781  hasFractionExpo = 1;
782  if (exponents[t] < 0)
783  hasNegativeExpo = 1;
784  }
785 
786  // ensure negative exponents are supplied along with a zero-index override
787  if (hasNegativeExpo) {
788  int hasZeroOverride = 0;
789  for (int v=0; v<numOverrides; v++) {
790  if (overrideInds[v] == 0LL) {
791  hasZeroOverride = 1;
792  break;
793  }
794  }
795  QuESTAssert(hasZeroOverride, E_NEGATIVE_EXPONENT_WITHOUT_ZERO_OVERRIDE, caller);
796  }
797 
798  // ensure fractional powers not used with negative numbers, unless overriden
799  if (hasFractionExpo && encoding == TWOS_COMPLEMENT) {
800  long long int numNegInds = (1LL << (numQubits-1));
801 
802  // immediately disqualify if insufficient overrides are given to cover every negative number
803  QuESTAssert(numOverrides >= numNegInds, E_FRACTIONAL_EXPONENT_WITHOUT_NEG_OVERRIDE, caller);
804 
805  int allNegsOverriden;
806 
807  // if there are 16 or fewer qubits (0.5mB cache), use a stack array to tick off overrides
808  if (numQubits < 16) {
809 
810  // flags for {-1,-2,...}; at index {abs(-1)-1, abs(-2)-2, ...}
811  long long int negIsOverriden[32768]; // [numNegInds];
812  for (int i=0; i<numNegInds; i++)
813  negIsOverriden[i] = 0;
814 
815  for (int v=0; v<numOverrides; v++)
816  if (overrideInds[v] < 0)
817  negIsOverriden[ -1 - overrideInds[v] ] = 1;
818 
819  allNegsOverriden = 1;
820  for (int i=0; i<numNegInds; i++) {
821  if (!negIsOverriden[i]) {
822  allNegsOverriden = 0;
823  break;
824  }
825  }
826  }
827  // otherwise, we must trust the user, else impose significant slowdowns on good users
828  else {
829  allNegsOverriden = 1;
830  }
831 
832  QuESTAssert(allNegsOverriden, E_FRACTIONAL_EXPONENT_WITHOUT_NEG_OVERRIDE, caller);
833  }
834 }

References E_FRACTIONAL_EXPONENT_WITHOUT_NEG_OVERRIDE, E_INVALID_NUM_PHASE_FUNC_TERMS, E_NEGATIVE_EXPONENT_WITHOUT_ZERO_OVERRIDE, QuESTAssert(), and TWOS_COMPLEMENT.

Referenced by applyPhaseFunc(), and applyPhaseFuncOverrides().

◆ validateProb()

void validateProb ( qreal  prob,
const char *  caller 
)

Definition at line 551 of file QuEST_validation.c.

551  {
552  QuESTAssert(prob >= 0 && prob <= 1, E_INVALID_PROB, caller);
553 }

References E_INVALID_PROB, and QuESTAssert().

Referenced by mixDensityMatrix(), validateNormProbs(), validateOneQubitDampingProb(), validateOneQubitDephaseProb(), validateOneQubitDepolProb(), validateOneQubitPauliProbs(), validateTwoQubitDephaseProb(), and validateTwoQubitDepolProb().

◆ validateQubitSubregs()

void validateQubitSubregs ( Qureg  qureg,
int *  qubits,
int *  numQubitsPerReg,
const int  numRegs,
const char *  caller 
)

Definition at line 757 of file QuEST_validation.c.

757  {
758  QuESTAssert(numRegs>0 && numRegs<=MAX_NUM_REGS_APPLY_ARBITRARY_PHASE, E_INVALID_NUM_SUBREGISTERS, caller);
759 
760  int i=0;
761  for (int r=0; r<numRegs; r++) {
762  QuESTAssert(numQubitsPerReg[r]>0 && numQubitsPerReg[r]<=qureg.numQubitsRepresented, E_INVALID_NUM_QUBITS, caller);
763 
764  for (int q=0; q < numQubitsPerReg[r]; q++) {
765  QuESTAssert(qubits[i]>=0 && qubits[i]<qureg.numQubitsRepresented, E_INVALID_QUBIT_INDEX, caller);
766  i++;
767  }
768  }
769 
770  QuESTAssert(areUniqueQubits(qubits, i), E_QUBITS_NOT_UNIQUE, caller);
771 }

References areUniqueQubits(), E_INVALID_NUM_QUBITS, E_INVALID_NUM_SUBREGISTERS, E_INVALID_QUBIT_INDEX, E_QUBITS_NOT_UNIQUE, MAX_NUM_REGS_APPLY_ARBITRARY_PHASE, Qureg::numQubitsRepresented, and QuESTAssert().

Referenced by applyMultiVarPhaseFunc(), applyMultiVarPhaseFuncOverrides(), applyNamedPhaseFunc(), applyNamedPhaseFuncOverrides(), applyParamNamedPhaseFunc(), and applyParamNamedPhaseFuncOverrides().

◆ validateSecondQuregStateVec()

void validateSecondQuregStateVec ( Qureg  qureg2,
const char *  caller 
)

Definition at line 539 of file QuEST_validation.c.

539  {
540  QuESTAssert( ! qureg2.isDensityMatrix, E_SECOND_ARG_MUST_BE_STATEVEC, caller);
541 }

References E_SECOND_ARG_MUST_BE_STATEVEC, Qureg::isDensityMatrix, and QuESTAssert().

Referenced by calcFidelity(), and initPureState().

◆ validateStateIndex()

void validateStateIndex ( Qureg  qureg,
long long int  stateInd,
const char *  caller 
)

Definition at line 377 of file QuEST_validation.c.

377  {
378  long long int stateMax = 1LL << qureg.numQubitsRepresented;
379  QuESTAssert(stateInd>=0 && stateInd<stateMax, E_INVALID_STATE_INDEX, caller);
380 }

References E_INVALID_STATE_INDEX, Qureg::numQubitsRepresented, and QuESTAssert().

Referenced by initClassicalState().

◆ validateStateVecQureg()

void validateStateVecQureg ( Qureg  qureg,
const char *  caller 
)

Definition at line 515 of file QuEST_validation.c.

515  {
516  QuESTAssert( ! qureg.isDensityMatrix, E_DEFINED_ONLY_FOR_STATEVECS, caller);
517 }

References E_DEFINED_ONLY_FOR_STATEVECS, Qureg::isDensityMatrix, and QuESTAssert().

Referenced by calcInnerProduct(), getAmp(), getImagAmp(), getNumAmps(), getProbAmp(), getRealAmp(), initStateOfSingleQubit(), and setAmps().

◆ validateTarget()

void validateTarget ( Qureg  qureg,
int  targetQubit,
const char *  caller 
)

Definition at line 400 of file QuEST_validation.c.

400  {
401  QuESTAssert(targetQubit>=0 && targetQubit<qureg.numQubitsRepresented, E_INVALID_TARGET_QUBIT, caller);
402 }

References E_INVALID_TARGET_QUBIT, Qureg::numQubitsRepresented, and QuESTAssert().

Referenced by applyMatrix2(), applyProjector(), calcProbOfOutcome(), collapseToOutcome(), compactUnitary(), hadamard(), initStateOfSingleQubit(), measure(), measureWithStats(), mixDamping(), mixDephasing(), mixDepolarising(), mixKrausMap(), mixPauli(), pauliX(), pauliY(), pauliZ(), phaseShift(), rotateAroundAxis(), rotateX(), rotateY(), rotateZ(), sGate(), tGate(), unitary(), validateControlTarget(), validateMultiControlsTarget(), validateMultiTargets(), and validateUniqueTargets().

◆ validateTrotterParams()

void validateTrotterParams ( int  order,
int  reps,
const char *  caller 
)

Definition at line 703 of file QuEST_validation.c.

703  {
704  int isEven = (order % 2) == 0;
705  QuESTAssert(order > 0 && (isEven || order==1), E_INVALID_TROTTER_ORDER, caller);
706  QuESTAssert(reps > 0, E_INVALID_TROTTER_REPS, caller);
707 }

References E_INVALID_TROTTER_ORDER, E_INVALID_TROTTER_REPS, and QuESTAssert().

Referenced by applyTrotterCircuit().

◆ validateTwoQubitDephaseProb()

void validateTwoQubitDephaseProb ( qreal  prob,
const char *  caller 
)

Definition at line 568 of file QuEST_validation.c.

568  {
569  validateProb(prob, caller);
570  QuESTAssert(prob <= 3/4.0, E_INVALID_TWO_QUBIT_DEPHASE_PROB, caller);
571 }

References E_INVALID_TWO_QUBIT_DEPHASE_PROB, QuESTAssert(), and validateProb().

Referenced by mixTwoQubitDephasing().

◆ validateTwoQubitDepolProb()

void validateTwoQubitDepolProb ( qreal  prob,
const char *  caller 
)

Definition at line 583 of file QuEST_validation.c.

583  {
584  validateProb(prob, caller);
585  QuESTAssert(prob <= 15/16.0, E_INVALID_TWO_QUBIT_DEPOL_PROB, caller);
586 }

References E_INVALID_TWO_QUBIT_DEPOL_PROB, QuESTAssert(), and validateProb().

Referenced by mixTwoQubitDepolarising().

◆ validateTwoQubitKrausMap()

void validateTwoQubitKrausMap ( Qureg  qureg,
ComplexMatrix4 *  ops,
int  numOps,
const char *  caller 
)

Definition at line 622 of file QuEST_validation.c.

622  {
623  int opNumQubits = 2;
624  int superOpNumQubits = 2*opNumQubits;
625  int maxNumOps = superOpNumQubits*superOpNumQubits;
626  QuESTAssert(numOps > 0 && numOps <= maxNumOps, E_INVALID_NUM_TWO_QUBIT_KRAUS_OPS, caller);
627 
628  validateMultiQubitMatrixFitsInNode(qureg, superOpNumQubits, caller);
629 
630  int isPos = isCompletelyPositiveMap4(ops, numOps);
631  QuESTAssert(isPos, E_INVALID_KRAUS_OPS, caller);
632 }

References E_INVALID_KRAUS_OPS, E_INVALID_NUM_TWO_QUBIT_KRAUS_OPS, isCompletelyPositiveMap4(), QuESTAssert(), and validateMultiQubitMatrixFitsInNode().

Referenced by mixTwoQubitKrausMap().

◆ validateTwoQubitUnitaryMatrix()

void validateTwoQubitUnitaryMatrix ( Qureg  qureg,
ComplexMatrix4  u,
const char *  caller 
)

Definition at line 481 of file QuEST_validation.c.

481  {
482  validateMultiQubitMatrixFitsInNode(qureg, 2, caller);
483  QuESTAssert(isMatrix4Unitary(u), E_NON_UNITARY_MATRIX, caller);
484 }

References E_NON_UNITARY_MATRIX, isMatrix4Unitary(), QuESTAssert(), and validateMultiQubitMatrixFitsInNode().

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

◆ validateUniqueTargets()

void validateUniqueTargets ( Qureg  qureg,
int  qubit1,
int  qubit2,
const char *  caller 
)

Definition at line 414 of file QuEST_validation.c.

414  {
415  validateTarget(qureg, qubit1, caller);
416  validateTarget(qureg, qubit2, caller);
417  QuESTAssert(qubit1 != qubit2, E_TARGETS_NOT_UNIQUE, caller);
418 }

References E_TARGETS_NOT_UNIQUE, QuESTAssert(), and validateTarget().

Referenced by mixTwoQubitDephasing(), mixTwoQubitDepolarising(), sqrtSwapGate(), and swapGate().

◆ validateUnitaryComplexPair()

void validateUnitaryComplexPair ( Complex  alpha,
Complex  beta,
const char *  caller 
)

Definition at line 507 of file QuEST_validation.c.

507  {
508  QuESTAssert(isComplexPairUnitary(alpha, beta), E_NON_UNITARY_COMPLEX_PAIR, caller);
509 }

References E_NON_UNITARY_COMPLEX_PAIR, isComplexPairUnitary(), and QuESTAssert().

Referenced by compactUnitary(), and controlledCompactUnitary().

◆ validateVector()

void validateVector ( Vector  vec,
const char *  caller 
)

Definition at line 511 of file QuEST_validation.c.

511  {
512  QuESTAssert(getVectorMagnitude(vec) > REAL_EPS, E_ZERO_VECTOR, caller);
513 }

References E_ZERO_VECTOR, getVectorMagnitude(), and QuESTAssert().

Referenced by controlledRotateAroundAxis(), and rotateAroundAxis().

Variable Documentation

◆ errMsgBuffer

char errMsgBuffer[1024]

Definition at line 30 of file QuEST_validation.c.

Referenced by validateFileOpened(), validateHamilFileCoeffParsed(), validateHamilFileParams(), validateHamilFilePauliCode(), and validateHamilFilePauliParsed().

◆ errorMessages

const char* errorMessages[]
static

Definition at line 116 of file QuEST_validation.c.

Referenced by QuESTAssert(), validateFileOpened(), validateHamilFileCoeffParsed(), validateHamilFileParams(), validateHamilFilePauliCode(), and validateHamilFilePauliParsed().

INVERSE_PRODUCT
@ INVERSE_PRODUCT
Definition: QuEST.h:233
pauliOpType
pauliOpType
Codes for specifying Pauli operators.
Definition: QuEST.h:96
E_INVALID_TWO_QUBIT_DEPOL_PROB
@ E_INVALID_TWO_QUBIT_DEPOL_PROB
Definition: QuEST_validation.c:72
E_NUM_AMPS_EXCEED_TYPE
@ E_NUM_AMPS_EXCEED_TYPE
Definition: QuEST_validation.c:87
validateTarget
void validateTarget(Qureg qureg, int targetQubit, const char *caller)
Definition: QuEST_validation.c:400
E_MISMATCHING_PAULI_HAMIL_DIAGONAL_OP_SIZE
@ E_MISMATCHING_PAULI_HAMIL_DIAGONAL_OP_SIZE
Definition: QuEST_validation.c:99
E_INVALID_QUBIT_OUTCOME
@ E_INVALID_QUBIT_OUTCOME
Definition: QuEST_validation.c:60
E_CANNOT_PARSE_PAULI_HAMIL_FILE_COEFF
@ E_CANNOT_PARSE_PAULI_HAMIL_FILE_COEFF
Definition: QuEST_validation.c:90
isMatrix2Unitary
int isMatrix2Unitary(ComplexMatrix2 u)
Definition: QuEST_validation.c:263
E_PAULI_HAMIL_NOT_DIAGONAL
@ E_PAULI_HAMIL_NOT_DIAGONAL
Definition: QuEST_validation.c:98
PAULI_Z
@ PAULI_Z
Definition: QuEST.h:96
DISTANCE
@ DISTANCE
Definition: QuEST.h:234
E_INVALID_NUM_PHASE_FUNC_TERMS
@ E_INVALID_NUM_PHASE_FUNC_TERMS
Definition: QuEST_validation.c:101
E_INVALID_PAULI_CODE
@ E_INVALID_PAULI_CODE
Definition: QuEST_validation.c:75
E_NON_UNITARY_MATRIX
@ E_NON_UNITARY_MATRIX
Definition: QuEST_validation.c:55
validateHamilParams
void validateHamilParams(int numQubits, int numTerms, const char *caller)
Definition: QuEST_validation.c:651
PAULI_I
@ PAULI_I
Definition: QuEST.h:96
E_INVALID_ONE_QUBIT_DEPHASE_PROB
@ E_INVALID_ONE_QUBIT_DEPHASE_PROB
Definition: QuEST_validation.c:69
validateMultiQubitMatrixFitsInNode
void validateMultiQubitMatrixFitsInNode(Qureg qureg, int numTargets, const char *caller)
Definition: QuEST_validation.c:473
E_INVALID_NUM_REGS_DISTANCE_PHASE_FUNC
@ E_INVALID_NUM_REGS_DISTANCE_PHASE_FUNC
Definition: QuEST_validation.c:113
E_CANNOT_FIT_MULTI_QUBIT_MATRIX
@ E_CANNOT_FIT_MULTI_QUBIT_MATRIX
Definition: QuEST_validation.c:77
E_INVALID_NUM_N_QUBIT_KRAUS_OPS
@ E_INVALID_NUM_N_QUBIT_KRAUS_OPS
Definition: QuEST_validation.c:82
E_INVALID_ELEM_INDEX
@ E_INVALID_ELEM_INDEX
Definition: QuEST_validation.c:41
isMatrix4Unitary
int isMatrix4Unitary(ComplexMatrix4 u)
Definition: QuEST_validation.c:269
TWOS_COMPLEMENT
@ TWOS_COMPLEMENT
Definition: QuEST.h:269
E_MISMATCHING_QUREG_TYPES
@ E_MISMATCHING_QUREG_TYPES
Definition: QuEST_validation.c:64
validateNumControls
void validateNumControls(Qureg qureg, int numControlQubits, const char *caller)
Definition: QuEST_validation.c:424
isCompletelyPositiveMap4
int isCompletelyPositiveMap4(ComplexMatrix4 *ops, int numOps)
Definition: QuEST_validation.c:303
E_CANNOT_PARSE_PAULI_HAMIL_FILE_PAULI
@ E_CANNOT_PARSE_PAULI_HAMIL_FILE_PAULI
Definition: QuEST_validation.c:91
macro_isCompletelyPositiveMap
#define macro_isCompletelyPositiveMap(ops, numOps, opDim)
Definition: QuEST_validation.c:282
E_INVALID_QUBIT_INDEX
@ E_INVALID_QUBIT_INDEX
Definition: QuEST_validation.c:36
E_INVALID_PHASE_FUNC_NAME
@ E_INVALID_PHASE_FUNC_NAME
Definition: QuEST_validation.c:105
validateProb
void validateProb(qreal prob, const char *caller)
Definition: QuEST_validation.c:551
E_INVALID_BIT_ENCODING
@ E_INVALID_BIT_ENCODING
Definition: QuEST_validation.c:107
NORM
@ NORM
Definition: QuEST.h:232
E_NON_UNITARY_COMPLEX_PAIR
@ E_NON_UNITARY_COMPLEX_PAIR
Definition: QuEST_validation.c:56
SCALED_INVERSE_DISTANCE
@ SCALED_INVERSE_DISTANCE
Definition: QuEST.h:234
UNSIGNED
@ UNSIGNED
Definition: QuEST.h:269
E_INVALID_NUM_SUBREGISTERS
@ E_INVALID_NUM_SUBREGISTERS
Definition: QuEST_validation.c:100
E_INVALID_CONTROLS_BIT_STATE
@ E_INVALID_CONTROLS_BIT_STATE
Definition: QuEST_validation.c:74
E_INVALID_TROTTER_ORDER
@ E_INVALID_TROTTER_ORDER
Definition: QuEST_validation.c:94
E_INVALID_NUM_TWO_QUBIT_KRAUS_OPS
@ E_INVALID_NUM_TWO_QUBIT_KRAUS_OPS
Definition: QuEST_validation.c:81
E_DISTRIB_DIAG_OP_TOO_SMALL
@ E_DISTRIB_DIAG_OP_TOO_SMALL
Definition: QuEST_validation.c:86
INVERSE_DISTANCE
@ INVERSE_DISTANCE
Definition: QuEST.h:234
E_SECOND_ARG_MUST_BE_STATEVEC
@ E_SECOND_ARG_MUST_BE_STATEVEC
Definition: QuEST_validation.c:62
E_INVALID_CONTROL_QUBIT
@ E_INVALID_CONTROL_QUBIT
Definition: QuEST_validation.c:38
E_INVALID_NUM_SUM_TERMS
@ E_INVALID_NUM_SUM_TERMS
Definition: QuEST_validation.c:76
E_DEFINED_ONLY_FOR_STATEVECS
@ E_DEFINED_ONLY_FOR_STATEVECS
Definition: QuEST_validation.c:65
qreal
#define qreal
validateMatrixInit
void validateMatrixInit(ComplexMatrixN matr, const char *caller)
Definition: QuEST_validation.c:486
isCompletelyPositiveMap2
int isCompletelyPositiveMap2(ComplexMatrix2 *ops, int numOps)
Definition: QuEST_validation.c:300
E_INVALID_PAULI_HAMIL_FILE_PAULI_CODE
@ E_INVALID_PAULI_HAMIL_FILE_PAULI_CODE
Definition: QuEST_validation.c:92
calcLog2
unsigned int calcLog2(long unsigned int num)
returns log2 of numbers which must be gauranteed to be 2^n
Definition: QuEST_validation.c:328
E_NEGATIVE_EXPONENT_MULTI_VAR
@ E_NEGATIVE_EXPONENT_MULTI_VAR
Definition: QuEST_validation.c:111
validateControl
void validateControl(Qureg qureg, int controlQubit, const char *caller)
Definition: QuEST_validation.c:404
macro_isMatrixUnitary
#define macro_isMatrixUnitary(m, dim, retVal)
Definition: QuEST_validation.c:236
PAULI_X
@ PAULI_X
Definition: QuEST.h:96
E_INVALID_PROB
@ E_INVALID_PROB
Definition: QuEST_validation.c:67
validateNumTargets
void validateNumTargets(Qureg qureg, int numTargetQubits, const char *caller)
Definition: QuEST_validation.c:420
isMatrixNUnitary
int isMatrixNUnitary(ComplexMatrixN u)
Definition: QuEST_validation.c:275
E_QUBITS_NOT_UNIQUE
@ E_QUBITS_NOT_UNIQUE
Definition: QuEST_validation.c:49
E_INVALID_PHASE_FUNC_OVERRIDE_TWOS_COMPLEMENT_INDEX
@ E_INVALID_PHASE_FUNC_OVERRIDE_TWOS_COMPLEMENT_INDEX
Definition: QuEST_validation.c:104
E_CONTROL_TARGET_COLLISION
@ E_CONTROL_TARGET_COLLISION
Definition: QuEST_validation.c:48
invalidQuESTInputError
void invalidQuESTInputError(const char *errMsg, const char *errFunc)
An internal function called when invalid arguments are passed to a QuEST API call,...
Definition: QuEST_validation.c:209
E_DEFINED_ONLY_FOR_DENSMATRS
@ E_DEFINED_ONLY_FOR_DENSMATRS
Definition: QuEST_validation.c:66
E_INVALID_KRAUS_OPS
@ E_INVALID_KRAUS_OPS
Definition: QuEST_validation.c:83
E_INVALID_OFFSET_NUM_AMPS_QUREG
@ E_INVALID_OFFSET_NUM_AMPS_QUREG
Definition: QuEST_validation.c:44
E_INVALID_STATE_INDEX
@ E_INVALID_STATE_INDEX
Definition: QuEST_validation.c:39
DiagonalOp::imag
qreal * imag
The imaginary values of the 2^numQubits complex elements.
Definition: QuEST.h:310
areUniqueQubits
int areUniqueQubits(int *qubits, int numQubits)
Definition: QuEST_validation.c:315
E_TARGET_IN_CONTROLS
@ E_TARGET_IN_CONTROLS
Definition: QuEST_validation.c:47
E_INVALID_NUM_QUBITS
@ E_INVALID_NUM_QUBITS
Definition: QuEST_validation.c:52
Qureg::numAmpsPerChunk
long long int numAmpsPerChunk
Number of probability amplitudes held in stateVec by this process In the non-MPI version,...
Definition: QuEST.h:332
E_TARGET_IS_CONTROL
@ E_TARGET_IS_CONTROL
Definition: QuEST_validation.c:46
E_INVALID_PAULI_HAMIL_PARAMS
@ E_INVALID_PAULI_HAMIL_PARAMS
Definition: QuEST_validation.c:88
E_INVALID_UNITARY_SIZE
@ E_INVALID_UNITARY_SIZE
Definition: QuEST_validation.c:78
E_INVALID_ONE_QUBIT_PAULI_PROBS
@ E_INVALID_ONE_QUBIT_PAULI_PROBS
Definition: QuEST_validation.c:73
PauliHamil::pauliCodes
enum pauliOpType * pauliCodes
The Pauli operators acting on each qubit, flattened over every operator.
Definition: QuEST.h:281
E_MISMATCHING_NUM_TARGS_KRAUS_SIZE
@ E_MISMATCHING_NUM_TARGS_KRAUS_SIZE
Definition: QuEST_validation.c:84
SCALED_PRODUCT
@ SCALED_PRODUCT
Definition: QuEST.h:233
validateMultiTargets
void validateMultiTargets(Qureg qureg, int *targetQubits, int numTargetQubits, const char *caller)
Definition: QuEST_validation.c:428
isValidPauliCode
int isValidPauliCode(enum pauliOpType code)
Definition: QuEST_validation.c:311
MAX_NUM_REGS_APPLY_ARBITRARY_PHASE
#define MAX_NUM_REGS_APPLY_ARBITRARY_PHASE
Definition: QuEST_precision.h:72
E_INVALID_TARGET_QUBIT
@ E_INVALID_TARGET_QUBIT
Definition: QuEST_validation.c:37
E_COMPLEX_MATRIX_NOT_INIT
@ E_COMPLEX_MATRIX_NOT_INIT
Definition: QuEST_validation.c:79
E_CANNOT_OPEN_FILE
@ E_CANNOT_OPEN_FILE
Definition: QuEST_validation.c:61
E_DISTRIB_QUREG_TOO_SMALL
@ E_DISTRIB_QUREG_TOO_SMALL
Definition: QuEST_validation.c:85
DiagonalOp::numQubits
int numQubits
The number of qubits this operator can act on (informing its size)
Definition: QuEST.h:300
E_INVALID_NUM_ONE_QUBIT_KRAUS_OPS
@ E_INVALID_NUM_ONE_QUBIT_KRAUS_OPS
Definition: QuEST_validation.c:80
PauliHamil::numSumTerms
int numSumTerms
The number of terms in the weighted sum, or the number of Pauli products.
Definition: QuEST.h:285
getQubitBitMask
long long int getQubitBitMask(int *qubits, int numQubits)
Definition: QuEST_common.c:50
E_MISMATCHING_QUREG_DIAGONAL_OP_SIZE
@ E_MISMATCHING_QUREG_DIAGONAL_OP_SIZE
Definition: QuEST_validation.c:96
PAULI_Y
@ PAULI_Y
Definition: QuEST.h:96
E_INVALID_AMP_INDEX
@ E_INVALID_AMP_INDEX
Definition: QuEST_validation.c:40
SCALED_INVERSE_SHIFTED_NORM
@ SCALED_INVERSE_SHIFTED_NORM
Definition: QuEST.h:232
ComplexMatrixN::real
qreal ** real
Definition: QuEST.h:189
E_INVALID_NUM_RANKS
@ E_INVALID_NUM_RANKS
Definition: QuEST_validation.c:34
E_INVALID_TWO_QUBIT_DEPHASE_PROB
@ E_INVALID_TWO_QUBIT_DEPHASE_PROB
Definition: QuEST_validation.c:70
E_MISMATCHING_PAULI_HAMIL_QUREG_NUM_QUBITS
@ E_MISMATCHING_PAULI_HAMIL_QUREG_NUM_QUBITS
Definition: QuEST_validation.c:93
errorMessages
static const char * errorMessages[]
Definition: QuEST_validation.c:116
QuESTAssert
void QuESTAssert(int isValid, ErrorCode code, const char *func)
Definition: QuEST_validation.c:216
E_INVALID_NUM_AMPS
@ E_INVALID_NUM_AMPS
Definition: QuEST_validation.c:42
E_COLLAPSE_STATE_ZERO_PROB
@ E_COLLAPSE_STATE_ZERO_PROB
Definition: QuEST_validation.c:59
E_TARGETS_NOT_UNIQUE
@ E_TARGETS_NOT_UNIQUE
Definition: QuEST_validation.c:50
INVERSE_NORM
@ INVERSE_NORM
Definition: QuEST.h:232
ComplexMatrixN::imag
qreal ** imag
Definition: QuEST.h:190
E_MISMATCHING_QUREG_DIMENSIONS
@ E_MISMATCHING_QUREG_DIMENSIONS
Definition: QuEST_validation.c:63
ErrorCode
ErrorCode
Definition: QuEST_validation.c:32
E_INVALID_TROTTER_REPS
@ E_INVALID_TROTTER_REPS
Definition: QuEST_validation.c:95
E_INVALID_NUM_CONTROLS
@ E_INVALID_NUM_CONTROLS
Definition: QuEST_validation.c:54
PRODUCT
@ PRODUCT
Definition: QuEST.h:233
errMsgBuffer
char errMsgBuffer[1024]
Definition: QuEST_validation.c:30
E_INVALID_NUM_CREATE_QUBITS
@ E_INVALID_NUM_CREATE_QUBITS
Definition: QuEST_validation.c:35
validateDiagOpInit
void validateDiagOpInit(DiagonalOp op, const char *caller)
Definition: QuEST_validation.c:709
E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS
@ E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS
Definition: QuEST_validation.c:106
Qureg::isDensityMatrix
int isDensityMatrix
Whether this instance is a density-state representation.
Definition: QuEST.h:325
ComplexMatrixN::numQubits
int numQubits
Definition: QuEST.h:188
validateAmpIndex
void validateAmpIndex(Qureg qureg, long long int ampInd, const char *caller)
Definition: QuEST_validation.c:382
E_INVALID_OFFSET_NUM_ELEMS_DIAG
@ E_INVALID_OFFSET_NUM_ELEMS_DIAG
Definition: QuEST_validation.c:45
getVectorMagnitude
qreal getVectorMagnitude(Vector vec)
Definition: QuEST_common.c:79
E_INVALID_PAULI_HAMIL_FILE_PARAMS
@ E_INVALID_PAULI_HAMIL_FILE_PARAMS
Definition: QuEST_validation.c:89
PauliHamil::numQubits
int numQubits
The number of qubits informing the Hilbert dimension of the Hamiltonian.
Definition: QuEST.h:287
E_UNNORM_PROBS
@ E_UNNORM_PROBS
Definition: QuEST_validation.c:68
Qureg::numQubitsRepresented
int numQubitsRepresented
The number of qubits represented in either the state-vector or density matrix.
Definition: QuEST.h:327
E_INVALID_NUM_PHASE_FUNC_OVERRIDES
@ E_INVALID_NUM_PHASE_FUNC_OVERRIDES
Definition: QuEST_validation.c:102
E_INVALID_PHASE_FUNC_OVERRIDE_UNSIGNED_INDEX
@ E_INVALID_PHASE_FUNC_OVERRIDE_UNSIGNED_INDEX
Definition: QuEST_validation.c:103
Qureg::numAmpsTotal
long long int numAmpsTotal
Total number of amplitudes, which are possibly distributed among machines.
Definition: QuEST.h:334
SCALED_DISTANCE
@ SCALED_DISTANCE
Definition: QuEST.h:234
DiagonalOp::real
qreal * real
The real values of the 2^numQubits complex elements.
Definition: QuEST.h:308
E_FRACTIONAL_EXPONENT_MULTI_VAR
@ E_FRACTIONAL_EXPONENT_MULTI_VAR
Definition: QuEST_validation.c:112
Complex::real
qreal real
Definition: QuEST.h:105
E_INVALID_NUM_QUBITS_TWOS_COMPLEMENT
@ E_INVALID_NUM_QUBITS_TWOS_COMPLEMENT
Definition: QuEST_validation.c:108
destroyPauliHamil
void destroyPauliHamil(PauliHamil h)
Destroy a PauliHamil instance, created with either createPauliHamil() or createPauliHamilFromFile().
Definition: QuEST.c:1414
isCompletelyPositiveMapN
int isCompletelyPositiveMapN(ComplexMatrixN *ops, int numOps)
Definition: QuEST_validation.c:306
Complex::imag
qreal imag
Definition: QuEST.h:106
validateMultiControls
void validateMultiControls(Qureg qureg, int *controlQubits, int numControlQubits, const char *caller)
Definition: QuEST_validation.c:436
E_INVALID_NUM_ELEMS
@ E_INVALID_NUM_ELEMS
Definition: QuEST_validation.c:43
validateMultiQubitMatrix
void validateMultiQubitMatrix(Qureg qureg, ComplexMatrixN u, int numTargs, const char *caller)
Definition: QuEST_validation.c:496
E_NEGATIVE_EXPONENT_WITHOUT_ZERO_OVERRIDE
@ E_NEGATIVE_EXPONENT_WITHOUT_ZERO_OVERRIDE
Definition: QuEST_validation.c:109
E_INVALID_NUM_TARGETS
@ E_INVALID_NUM_TARGETS
Definition: QuEST_validation.c:53
E_SYS_TOO_BIG_TO_PRINT
@ E_SYS_TOO_BIG_TO_PRINT
Definition: QuEST_validation.c:58
SCALED_INVERSE_SHIFTED_DISTANCE
@ SCALED_INVERSE_SHIFTED_DISTANCE
Definition: QuEST.h:234
SCALED_NORM
@ SCALED_NORM
Definition: QuEST.h:232
SCALED_INVERSE_PRODUCT
@ SCALED_INVERSE_PRODUCT
Definition: QuEST.h:233
isComplexPairUnitary
int isComplexPairUnitary(Complex alpha, Complex beta)
Definition: QuEST_validation.c:228
validatePauliCodes
void validatePauliCodes(enum pauliOpType *pauliCodes, int numPauliCodes, const char *caller)
Definition: QuEST_validation.c:599
E_DIAGONAL_OP_NOT_INITIALISED
@ E_DIAGONAL_OP_NOT_INITIALISED
Definition: QuEST_validation.c:97
E_INVALID_ONE_QUBIT_DEPOL_PROB
@ E_INVALID_ONE_QUBIT_DEPOL_PROB
Definition: QuEST_validation.c:71
E_SUCCESS
@ E_SUCCESS
Definition: QuEST_validation.c:33
E_ZERO_VECTOR
@ E_ZERO_VECTOR
Definition: QuEST_validation.c:57
E_CONTROLS_NOT_UNIQUE
@ E_CONTROLS_NOT_UNIQUE
Definition: QuEST_validation.c:51
E_FRACTIONAL_EXPONENT_WITHOUT_NEG_OVERRIDE
@ E_FRACTIONAL_EXPONENT_WITHOUT_NEG_OVERRIDE
Definition: QuEST_validation.c:110
SCALED_INVERSE_NORM
@ SCALED_INVERSE_NORM
Definition: QuEST.h:232