#include "QuEST.h"
#include "QuEST_precision.h"
#include "QuEST_internal.h"
#include "QuEST_validation.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

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_NUM_AMPS, E_INVALID_OFFSET_NUM_AMPS, 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_NUM_AMPS_EXCEED_TYPE }

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	exitWithError (const char msg, const char func)

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	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	validateControl (Qureg qureg, int controlQubit, const char *caller)

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

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

void	validateDensityMatrQureg (Qureg qureg, const char *caller)

void	validateFileOpened (int found, const char *caller)

void	validateMatchingQuregDims (Qureg qureg1, Qureg qureg2, 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, const int numControlQubits, const char caller)

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

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

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

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

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

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

void	validateMultiTargets (Qureg qureg, int targetQubits, const int numTargetQubits, 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, const int numControlQubits, const char *caller)

void	validateNumPauliSumTerms (int numTerms, 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, const 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	validateProb (qreal prob, 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	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
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 212 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 166 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_NUM_AMPS
E_INVALID_OFFSET_NUM_AMPS
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_NUM_AMPS_EXCEED_TYPE

Definition at line 26 of file QuEST_validation.c.

              {
     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_NUM_AMPS,
     E_INVALID_OFFSET_NUM_AMPS,
     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_NUM_AMPS_EXCEED_TYPE
 } ErrorCode;

Function Documentation

◆ areUniqueQubits()

int areUniqueQubits	(	int *	qubits,
		int	numQubits
	)

Definition at line 241 of file QuEST_validation.c.

                                                 {
     long long int mask = 0;
     long long int bit;
     for (int q=0; q < numQubits; q++) {
         bit = 1LL << qubits[q];
         if (mask & bit)
             return 0;
         mask |= bit;
     }
     return 1;
 }

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

◆ exitWithError()

void exitWithError	(	const char *	msg,
		const char *	func
	)

Definition at line 133 of file QuEST_validation.c.

                                                       {
     printf("!!!\n");
     printf("QuEST Error in function %s: %s\n", func, msg);
     printf("!!!\n");
     printf("exiting..\n");
     exit(1);
 }

Referenced by invalidQuESTInputError().

◆ isCompletelyPositiveMap2()

int isCompletelyPositiveMap2	(	ComplexMatrix2 *	ops,
		int	numOps
	)

Definition at line 230 of file QuEST_validation.c.

                                                               {
     macro_isCompletelyPositiveMap(ops, numOps, 2);    
 }

References macro_isCompletelyPositiveMap.

Referenced by validateOneQubitKrausMap().

◆ isCompletelyPositiveMap4()

int isCompletelyPositiveMap4	(	ComplexMatrix4 *	ops,
		int	numOps
	)

Definition at line 233 of file QuEST_validation.c.

                                                               {
     macro_isCompletelyPositiveMap(ops, numOps, 4);
 }

References macro_isCompletelyPositiveMap.

Referenced by validateTwoQubitKrausMap().

◆ isCompletelyPositiveMapN()

int isCompletelyPositiveMapN	(	ComplexMatrixN *	ops,
		int	numOps
	)

Definition at line 236 of file QuEST_validation.c.

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

References macro_isCompletelyPositiveMap, and ComplexMatrixN::numQubits.

Referenced by validateMultiQubitKrausMap().

◆ isComplexPairUnitary()

int isComplexPairUnitary	(	Complex	alpha,
		Complex	beta
	)

Definition at line 158 of file QuEST_validation.c.

                                                       {
     return ( absReal( -1
                 + alpha.real*alpha.real 
                 + alpha.imag*alpha.imag
                 + beta.real*beta.real 
                 + beta.imag*beta.imag) < REAL_EPS );
 }

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

Referenced by validateUnitaryComplexPair().

◆ isComplexUnit()

int isComplexUnit ( Complex alpha )

Definition at line 150 of file QuEST_validation.c.

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

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

◆ isMatrix2Unitary()

int isMatrix2Unitary ( ComplexMatrix2 u )

Definition at line 193 of file QuEST_validation.c.

                                        {
     int dim = 2;
     int retVal;
     macro_isMatrixUnitary(u, dim, retVal);
     return retVal;
 }

References macro_isMatrixUnitary.

Referenced by validateOneQubitUnitaryMatrix().

◆ isMatrix4Unitary()

int isMatrix4Unitary ( ComplexMatrix4 u )

Definition at line 199 of file QuEST_validation.c.

                                        {
     int dim = 4;
     int retVal;
     macro_isMatrixUnitary(u, dim, retVal);
     return retVal;
 }

References macro_isMatrixUnitary.

Referenced by validateTwoQubitUnitaryMatrix().

◆ isMatrixNUnitary()

int isMatrixNUnitary ( ComplexMatrixN u )

Definition at line 205 of file QuEST_validation.c.

                                        {
     int dim = 1 << u.numQubits;
     int retVal;
     macro_isMatrixUnitary(u, dim, retVal);
     return retVal;
 }

References macro_isMatrixUnitary, and ComplexMatrixN::numQubits.

Referenced by validateMultiQubitUnitaryMatrix().

◆ isVectorUnit()

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

Definition at line 154 of file QuEST_validation.c.

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

◆ QuESTAssert()

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

Definition at line 146 of file QuEST_validation.c.

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

References errorMessages, and invalidQuESTInputError().

Referenced by validateAmpIndex(), validateControl(), validateControlState(), validateControlTarget(), validateDensityMatrQureg(), validateFileOpened(), validateMatchingQuregDims(), validateMatchingQuregTypes(), validateMatrixInit(), validateMeasurementProb(), validateMultiControls(), validateMultiControlsMultiTargets(), validateMultiControlsTarget(), validateMultiQubitKrausMap(), validateMultiQubitMatrixFitsInNode(), validateMultiQubits(), validateMultiQubitUnitaryMatrix(), validateMultiTargets(), validateNormProbs(), validateNumAmps(), validateNumControls(), validateNumPauliSumTerms(), validateNumQubitsInMatrix(), validateNumQubitsInQureg(), validateNumRanks(), validateNumTargets(), validateOneQubitDampingProb(), validateOneQubitDephaseProb(), validateOneQubitDepolProb(), validateOneQubitKrausMap(), validateOneQubitPauliProbs(), validateOneQubitUnitaryMatrix(), validateOutcome(), validatePauliCodes(), validateProb(), validateSecondQuregStateVec(), validateStateIndex(), validateStateVecQureg(), validateTarget(), validateTwoQubitDephaseProb(), validateTwoQubitDepolProb(), validateTwoQubitKrausMap(), validateTwoQubitUnitaryMatrix(), validateUniqueTargets(), validateUnitaryComplexPair(), and validateVector().

◆ validateAmpIndex()

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

Definition at line 296 of file QuEST_validation.c.

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

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

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

◆ validateControl()

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

Definition at line 311 of file QuEST_validation.c.

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

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

Referenced by validateControlTarget(), and validateMultiControls().

◆ validateControlState()

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

Definition at line 375 of file QuEST_validation.c.

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

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 315 of file QuEST_validation.c.

                                                                                                {
     validateTarget(qureg, targetQubit, caller);
     validateControl(qureg, controlQubit, caller);
     QuESTAssert(controlQubit != targetQubit, E_TARGET_IS_CONTROL, caller);
 }

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 422 of file QuEST_validation.c.

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

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().

◆ validateFileOpened()

void validateFileOpened	(	int	found,
		const char *	caller
	)

Definition at line 446 of file QuEST_validation.c.

                                                        {
     QuESTAssert(found, E_CANNOT_OPEN_FILE, caller);
 }

References E_CANNOT_OPEN_FILE, and QuESTAssert().

Referenced by initStateFromSingleFile(), and writeRecordedQASMToFile().

◆ validateMatchingQuregDims()

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

Definition at line 434 of file QuEST_validation.c.

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

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

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

◆ validateMatchingQuregTypes()

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

Definition at line 438 of file QuEST_validation.c.

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

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

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

◆ validateMatrixInit()

void validateMatrixInit	(	ComplexMatrixN	matr,
		const char *	caller
	)

Definition at line 393 of file QuEST_validation.c.

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

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

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

◆ validateMeasurementProb()

void validateMeasurementProb	(	qreal	prob,
		const char *	caller
	)

Definition at line 430 of file QuEST_validation.c.

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

References E_COLLAPSE_STATE_ZERO_PROB, and QuESTAssert().

Referenced by collapseToOutcome().

◆ validateMultiControls()

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

Definition at line 343 of file QuEST_validation.c.

                                                                                                             {
     validateNumControls(qureg, numControlQubits, caller);
     for (int i=0; i < numControlQubits; i++)
         validateControl(qureg, controlQubits[i], caller);
         
     QuESTAssert(areUniqueQubits(controlQubits, numControlQubits), E_CONTROLS_NOT_UNIQUE, caller);
 }

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

Referenced by validateMultiControlsMultiTargets(), and validateMultiControlsTarget().

◆ validateMultiControlsMultiTargets()

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

Definition at line 366 of file QuEST_validation.c.

                                                                                                                                                                       {
     validateMultiControls(qureg, controlQubits, numControlQubits, caller);
     validateMultiTargets(qureg, targetQubits, numTargetQubits, caller);
     long long int ctrlMask = getQubitBitMask(controlQubits, numControlQubits);
     long long int targMask = getQubitBitMask(targetQubits, numTargetQubits);
     int overlap = ctrlMask & targMask;
     QuESTAssert(!overlap, E_CONTROL_TARGET_COLLISION, caller);
 }

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

Referenced by controlledMultiQubitUnitary(), controlledTwoQubitUnitary(), multiControlledMultiQubitUnitary(), and multiControlledTwoQubitUnitary().

◆ validateMultiControlsTarget()

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

Definition at line 359 of file QuEST_validation.c.

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

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 535 of file QuEST_validation.c.

                                                                                                                 {
     int opNumQubits = numTargs;
     int superOpNumQubits = 2*opNumQubits;
     int maxNumOps = superOpNumQubits*superOpNumQubits;
     QuESTAssert(numOps>0 && numOps <= maxNumOps, E_INVALID_NUM_N_QUBIT_KRAUS_OPS, caller);
         
     for (int n=0; n<numOps; n++) {
         validateMatrixInit(ops[n], __func__);
         QuESTAssert(ops[n].numQubits == numTargs, E_MISMATCHING_NUM_TARGS_KRAUS_SIZE, caller);    
     }
     
     validateMultiQubitMatrixFitsInNode(qureg, superOpNumQubits, caller);
     
     int isPos = isCompletelyPositiveMapN(ops, numOps);
     QuESTAssert(isPos, E_INVALID_KRAUS_OPS, caller);
 }

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().

◆ validateMultiQubitMatrixFitsInNode()

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

Definition at line 380 of file QuEST_validation.c.

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

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

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

◆ validateMultiQubits()

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

Definition at line 351 of file QuEST_validation.c.

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

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

Referenced by multiControlledPhaseFlip(), and multiControlledPhaseShift().

◆ validateMultiQubitUnitaryMatrix()

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

Definition at line 403 of file QuEST_validation.c.

                                                                                                       { 
     validateMatrixInit(u, caller);
     validateMultiQubitMatrixFitsInNode(qureg, numTargs, caller);
     QuESTAssert(numTargs == u.numQubits, E_INVALID_UNITARY_SIZE, caller);
     QuESTAssert(isMatrixNUnitary(u), E_NON_UNITARY_MATRIX, caller);
 }

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

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

◆ validateMultiTargets()

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

Definition at line 335 of file QuEST_validation.c.

                                                                                                          {
     validateNumTargets(qureg, numTargetQubits, caller);
     for (int i=0; i < numTargetQubits; i++) 
         validateTarget(qureg, targetQubits[i], caller);
         
     QuESTAssert(areUniqueQubits(targetQubits, numTargetQubits), E_TARGETS_NOT_UNIQUE, caller);
 }

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

Referenced by calcExpecPauliProd(), mixMultiQubitKrausMap(), mixTwoQubitKrausMap(), multiQubitUnitary(), multiRotatePauli(), multiRotateZ(), twoQubitUnitary(), and validateMultiControlsMultiTargets().

◆ validateNormProbs()

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

Definition at line 454 of file QuEST_validation.c.

                                                                      {
     validateProb(prob1, caller);
     validateProb(prob2, caller);
     
     qreal sum = prob1 + prob2;
     QuESTAssert(absReal(1 - sum) < REAL_EPS, E_UNNORM_PROBS, caller);
 }

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 301 of file QuEST_validation.c.

                                                                                                      {
     validateAmpIndex(qureg, startInd, caller);
     QuESTAssert(numAmps >= 0 && numAmps <= qureg.numAmpsTotal, E_INVALID_NUM_AMPS, caller);
     QuESTAssert(numAmps + startInd <= qureg.numAmpsTotal, E_INVALID_OFFSET_NUM_AMPS, caller);
 }

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

Referenced by setAmps().

◆ validateNumControls()

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

Definition at line 331 of file QuEST_validation.c.

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

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

Referenced by validateMultiControls().

◆ validateNumPauliSumTerms()

void validateNumPauliSumTerms	(	int	numTerms,
		const char *	caller
	)

Definition at line 507 of file QuEST_validation.c.

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

References E_INVALID_NUM_SUM_TERMS, and QuESTAssert().

Referenced by applyPauliSum(), and calcExpecPauliSum().

◆ validateNumQubitsInMatrix()

void validateNumQubitsInMatrix	(	int	numQubits,
		const char *	caller
	)

Definition at line 287 of file QuEST_validation.c.

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

References E_INVALID_NUM_QUBITS, and QuESTAssert().

Referenced by createComplexMatrixN().

◆ validateNumQubitsInQureg()

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

Definition at line 275 of file QuEST_validation.c.

                                                                                {
     QuESTAssert(numQubits>0, E_INVALID_NUM_CREATE_QUBITS, caller);
     
     // mustn't be more amplitudes than can fit in the type
     unsigned int maxQubits = calcLog2(SIZE_MAX);
     QuESTAssert( numQubits <= maxQubits, E_NUM_AMPS_EXCEED_TYPE, caller);
     
     // must be at least one amplitude per node
     long unsigned int numAmps = (1<<numQubits);
     QuESTAssert(numAmps >= numRanks, E_DISTRIB_QUREG_TOO_SMALL, caller);
 }

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 261 of file QuEST_validation.c.

                                                         {
  
     /* silly but robust way to determine if numRanks is a power of 2, 
      * in lieu of bit-twiddling (e.g. AND with all-ones) which may be 
      * system / precsision dependent 
      */
     int isValid = 0;
     for (int exp2 = 1; exp2 <= numRanks; exp2 *= 2)
         if (exp2 == numRanks)
             isValid = 1;
     
     QuESTAssert(isValid, E_INVALID_NUM_RANKS, caller);
 }

References E_INVALID_NUM_RANKS, and QuESTAssert().

Referenced by createQuESTEnv().

◆ validateNumTargets()

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

Definition at line 327 of file QuEST_validation.c.

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

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

Referenced by validateMultiTargets().

◆ validateOneQubitDampingProb()

void validateOneQubitDampingProb	(	qreal	prob,
		const char *	caller
	)

Definition at line 477 of file QuEST_validation.c.

                                                                  {
     validateProb(prob, caller);
     QuESTAssert(prob <= 1.0, E_INVALID_ONE_QUBIT_DEPOL_PROB, caller);
 }

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

Referenced by mixDamping().

◆ validateOneQubitDephaseProb()

void validateOneQubitDephaseProb	(	qreal	prob,
		const char *	caller
	)

Definition at line 462 of file QuEST_validation.c.

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

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

Referenced by mixDephasing().

◆ validateOneQubitDepolProb()

void validateOneQubitDepolProb	(	qreal	prob,
		const char *	caller
	)

Definition at line 472 of file QuEST_validation.c.

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

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 511 of file QuEST_validation.c.

                                                                                                 {
     int opNumQubits = 1;
     int superOpNumQubits = 2*opNumQubits;
     int maxNumOps = superOpNumQubits*superOpNumQubits;
     QuESTAssert(numOps > 0 && numOps <= maxNumOps, E_INVALID_NUM_ONE_QUBIT_KRAUS_OPS, caller);
     
     validateMultiQubitMatrixFitsInNode(qureg, superOpNumQubits, caller);
     
     int isPos = isCompletelyPositiveMap2(ops, numOps);
     QuESTAssert(isPos, E_INVALID_KRAUS_OPS, caller);
 }

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 487 of file QuEST_validation.c.

                                                                                            {
     validateProb(probX, caller);
     validateProb(probY, caller);
     validateProb(probZ, caller);
     
     qreal probNoError = 1 - probX - probY - probZ;
     QuESTAssert(probX <= probNoError, E_INVALID_ONE_QUBIT_PAULI_PROBS, caller);
     QuESTAssert(probY <= probNoError, E_INVALID_ONE_QUBIT_PAULI_PROBS, caller);
     QuESTAssert(probZ <= probNoError, E_INVALID_ONE_QUBIT_PAULI_PROBS, caller);
 }

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

                                                                          {
     QuESTAssert(isMatrix2Unitary(u), E_NON_UNITARY_MATRIX, caller);
 }

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 426 of file QuEST_validation.c.

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

References E_INVALID_QUBIT_OUTCOME, and QuESTAssert().

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

◆ validatePauliCodes()

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

Definition at line 498 of file QuEST_validation.c.

                                                                                              {
     for (int i=0; i < numPauliCodes; i++) {
         int code = pauliCodes[i];
         QuESTAssert(
             code==PAULI_I || code==PAULI_X || code==PAULI_Y || code==PAULI_Z, 
             E_INVALID_PAULI_CODE, caller);
     }
 }

References E_INVALID_PAULI_CODE, PAULI_I, PAULI_X, PAULI_Y, PAULI_Z, and QuESTAssert().

Referenced by applyPauliSum(), calcExpecPauliProd(), calcExpecPauliSum(), and multiRotatePauli().

◆ validateProb()

void validateProb	(	qreal	prob,
		const char *	caller
	)

Definition at line 450 of file QuEST_validation.c.

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

References E_INVALID_PROB, and QuESTAssert().

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

◆ validateSecondQuregStateVec()

void validateSecondQuregStateVec	(	Qureg	qureg2,
		const char *	caller
	)

Definition at line 442 of file QuEST_validation.c.

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

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 291 of file QuEST_validation.c.

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

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

Referenced by initClassicalState().

◆ validateStateVecQureg()

void validateStateVecQureg	(	Qureg	qureg,
		const char *	caller
	)

Definition at line 418 of file QuEST_validation.c.

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

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

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

◆ validateTarget()

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

Definition at line 307 of file QuEST_validation.c.

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

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

Referenced by 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().

◆ validateTwoQubitDephaseProb()

void validateTwoQubitDephaseProb	(	qreal	prob,
		const char *	caller
	)

Definition at line 467 of file QuEST_validation.c.

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

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

Referenced by mixTwoQubitDephasing().

◆ validateTwoQubitDepolProb()

void validateTwoQubitDepolProb	(	qreal	prob,
		const char *	caller
	)

Definition at line 482 of file QuEST_validation.c.

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

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 523 of file QuEST_validation.c.

                                                                                                 {
     int opNumQubits = 2;
     int superOpNumQubits = 2*opNumQubits;
     int maxNumOps = superOpNumQubits*superOpNumQubits;
     QuESTAssert(numOps > 0 && numOps <= maxNumOps, E_INVALID_NUM_TWO_QUBIT_KRAUS_OPS, caller);
     
     validateMultiQubitMatrixFitsInNode(qureg, superOpNumQubits, caller);
  
     int isPos = isCompletelyPositiveMap4(ops, numOps);
     QuESTAssert(isPos, E_INVALID_KRAUS_OPS, caller);
 }

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 388 of file QuEST_validation.c.

                                                                                       {
     validateMultiQubitMatrixFitsInNode(qureg, 2, caller);
     QuESTAssert(isMatrix4Unitary(u), E_NON_UNITARY_MATRIX, caller);
 }

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 321 of file QuEST_validation.c.

                                                                                     {
     validateTarget(qureg, qubit1, caller);
     validateTarget(qureg, qubit2, caller);
     QuESTAssert(qubit1 != qubit2, E_TARGETS_NOT_UNIQUE, caller);
 }

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 410 of file QuEST_validation.c.

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

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 414 of file QuEST_validation.c.

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

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

Referenced by controlledRotateAroundAxis(), and rotateAroundAxis().

Variable Documentation

◆ errorMessages

const char* errorMessages[]

static

Definition at line 80 of file QuEST_validation.c.

Referenced by QuESTAssert().

Macros

Enumerations

Functions

Variables