QuEST_validation.h File Reference

#include "QuEST.h"
#include <stdio.h>

Go to the source code of this file.

Functions
void	validateAmpIndex (Qureg qureg, long long int ampInd, const char *caller)
void	validateBitEncoding (int numQubits, enum bitEncoding encoding, 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, const char *caller)
void	validateDiagPauliHamil (DiagonalOp op, PauliHamil hamil, const char *caller)
void	validateDiagPauliHamilFromFile (PauliHamil h, 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 qurge, 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	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	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 numReg, 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 vector, const char *caller)

Detailed Description

Provides validation defined in QuEST_validation.c which is used exclusively by QuEST.c

Author

Tyson Jones

Ania Brown (original testing of qubit indices, unitarity, valid collapse probability)

Balint Koczor (Kraus maps)

Definition in file QuEST_validation.h.

Function Documentation

validateAmpIndex()

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

Definition at line 382 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().

validateBitEncoding()

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

Definition at line 966 of file QuEST_validation.c.

                                                                                       {
    QuESTAssert(
        encoding == UNSIGNED ||
        encoding == TWOS_COMPLEMENT,
            E_INVALID_BIT_ENCODING, caller);
 
    if (encoding == TWOS_COMPLEMENT)
        QuESTAssert(numQubits > 1, E_INVALID_NUM_QUBITS_TWOS_COMPLEMENT, caller);
}

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

Referenced by applyPhaseFunc(), and applyPhaseFuncOverrides().

validateControlState()

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

Definition at line 468 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 408 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 519 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().

validateDiagonalOp()

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

Definition at line 713 of file QuEST_validation.c.

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

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

Referenced by applyDiagonalOp(), and calcExpecDiagonalOp().

validateDiagOpInit()

void validateDiagOpInit	(	DiagonalOp	,
		const char *	caller
	)

Definition at line 709 of file QuEST_validation.c.

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

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.

                                                                                 {
    QuESTAssert(op.numQubits == hamil.numQubits, E_MISMATCHING_PAULI_HAMIL_DIAGONAL_OP_SIZE, caller);
    
    for (int p=0; p<hamil.numSumTerms*hamil.numQubits; p++)
        QuESTAssert(
            hamil.pauliCodes[p] == PAULI_I || hamil.pauliCodes[p] == PAULI_Z,
            E_PAULI_HAMIL_NOT_DIAGONAL, caller);
}

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	h,
		int	numRanks,
		const char *	caller
	)

Definition at line 727 of file QuEST_validation.c.

                                                                                        {
    // hamil itself already validated as general Pauli Hamiltonian
    
    // destroy hamil before raising exceptions if validation fails
    int isValid;
    
    // mustn't be more elements than can fit in the type
    unsigned int maxQubits = calcLog2(SIZE_MAX);
    isValid = hamil.numQubits <= maxQubits;
    if (!isValid)
        destroyPauliHamil(hamil);
    QuESTAssert(isValid, E_NUM_AMPS_EXCEED_TYPE, caller);
    
    // must be at least one amplitude per node
    long unsigned int numElems = (1UL<<hamil.numQubits);
    isValid = numElems >= numRanks;
    if (!isValid)
        destroyPauliHamil(hamil);
    QuESTAssert(isValid, E_DISTRIB_DIAG_OP_TOO_SMALL, caller);
    
    // must contain only I and Z
    for (int p=0; p<hamil.numSumTerms*hamil.numQubits; p++) {
        isValid = hamil.pauliCodes[p] == PAULI_I || hamil.pauliCodes[p] == PAULI_Z;
        if (!isValid)
            destroyPauliHamil(hamil);
            
        QuESTAssert(isValid, E_PAULI_HAMIL_NOT_DIAGONAL, caller);
    }
}

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.

                                                                  {
    if (!opened) {
        
        sprintf(errMsgBuffer, errorMessages[E_CANNOT_OPEN_FILE], fn);
        invalidQuESTInputError(errMsgBuffer, caller);
    }
}

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.

                                                                                                      {
    if (!parsed) {
        destroyPauliHamil(h);
        fclose(file);
        
        sprintf(errMsgBuffer, errorMessages[E_CANNOT_PARSE_PAULI_HAMIL_FILE_COEFF], fn);
        invalidQuESTInputError(errMsgBuffer, caller);
    }
}

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.

                                                                                                    {
    if (!(numQubits > 0 && numTerms > 0)) {
        fclose(file);
 
        sprintf(errMsgBuffer, errorMessages[E_INVALID_PAULI_HAMIL_FILE_PARAMS], fn);
        invalidQuESTInputError(errMsgBuffer, caller);
    }
}

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.

                                                                                                               {
    if (!isValidPauliCode(code)) {
        destroyPauliHamil(h);
        fclose(file);
        
        sprintf(errMsgBuffer, errorMessages[E_INVALID_PAULI_HAMIL_FILE_PAULI_CODE], fn, code);
        invalidQuESTInputError(errMsgBuffer, caller);
    }
}

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.

                                                                                                      {
    if (!parsed) {
        destroyPauliHamil(h);
        fclose(file);
        
        sprintf(errMsgBuffer, errorMessages[E_CANNOT_PARSE_PAULI_HAMIL_FILE_PAULI], fn);
        invalidQuESTInputError(errMsgBuffer, caller);
    }
}

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.

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

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.

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

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.

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

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.

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

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.

                                                                 {
    
    /* 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 validateMultiQubitMatrix().

validateMeasurementProb()

void validateMeasurementProb	(	qreal	prob,
		const char *	caller
	)

Definition at line 527 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,
		int	numControlQubits,
		const char *	caller
	)

Definition at line 436 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,
		int	numControlQubits,
		int *	targetQubits,
		int	numTargetQubits,
		const char *	caller
	)

Definition at line 459 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 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.

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

validateMultiQubitMatrix()

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

Definition at line 496 of file QuEST_validation.c.

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

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.

                                                                                         {
    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 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.

                                                                                      {
    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 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.

                                                                                                      { 
    validateMultiQubitMatrix(qureg, u, numTargs, caller);
    QuESTAssert(isMatrixNUnitary(u), E_NON_UNITARY_MATRIX, caller);
}

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.

                                                                                                                   {
    QuESTAssert(
        encoding == UNSIGNED ||
        encoding == TWOS_COMPLEMENT,
            E_INVALID_BIT_ENCODING, caller);
 
    if (encoding == TWOS_COMPLEMENT)
        for (int r=0; r<numRegs; r++)
            QuESTAssert(numQubitsPerReg[r] > 1, E_INVALID_NUM_QUBITS_TWOS_COMPLEMENT, caller);
}

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	qurge,
		int *	targetQubits,
		int	numTargetQubits,
		const char *	caller
	)

Definition at line 428 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 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.

                                                                                                                                                                               {
    QuESTAssert(numOverrides>=0, E_INVALID_NUM_PHASE_FUNC_OVERRIDES, caller);
 
    if (encoding == UNSIGNED) {
        int i=0;
        for (int v=0; v<numOverrides; v++) {
            for (int r=0; r<numRegs; r++) {
                long long int maxInd = (1LL << numQubitsPerReg[r]) - 1;
                QuESTAssert(overrideInds[i]>=0 && overrideInds[i]<=maxInd, E_INVALID_PHASE_FUNC_OVERRIDE_UNSIGNED_INDEX, caller);
                i++;
            }
        }
    }
    else if (encoding == TWOS_COMPLEMENT) {
        int i=0;
        for (int v=0; v<numOverrides; v++) {
            for (int r=0; r<numRegs; r++) {
                int numValQubits = numQubitsPerReg[r] - 1; // removing sign bit
                long long int minInd = - (1LL << numValQubits);
                long long int maxInd = (1LL << numValQubits) - 1;
                QuESTAssert(overrideInds[i]>=minInd && overrideInds[i]<=maxInd, E_INVALID_PHASE_FUNC_OVERRIDE_TWOS_COMPLEMENT_INDEX, caller);
                i++;
            }
        }
    }
}

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.

                                                                                                                                                             {
    QuESTAssert(numRegs>0 && numRegs<=MAX_NUM_REGS_APPLY_ARBITRARY_PHASE, E_INVALID_NUM_SUBREGISTERS, caller);
    for (int r=0; r<numRegs; r++)
        QuESTAssert(numTermsPerReg[r]>0, E_INVALID_NUM_PHASE_FUNC_TERMS, caller);
        
    int numTotalTerms = 0;
    for (int r=0; r<numRegs; r++)
        numTotalTerms += numTermsPerReg[r];
    
    int hasFractionExpo = 0;
    int hasNegativeExpo = 0;
    for (int t=0; t<numTotalTerms; t++) {
        // this is only true if exponent is precisely an integer, else pow() will NaN
        if (floor(exponents[t]) != exponents[t])
            hasFractionExpo = 1;
        if (exponents[t] < 0)
            hasNegativeExpo = 1;
    }
    
    QuESTAssert(!hasNegativeExpo, E_NEGATIVE_EXPONENT_MULTI_VAR, caller);
    
    if (encoding == TWOS_COMPLEMENT)
        QuESTAssert(!hasFractionExpo, E_FRACTIONAL_EXPONENT_MULTI_VAR, caller);
}

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.

                                                                     {
    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 387 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_QUREG, caller);
}

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

Referenced by setAmps().

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.

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

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.

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

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.

                                                                                {
    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 = (1UL<<numQubits);
    QuESTAssert(numAmps >= numRanks, E_DISTRIB_DIAG_OP_TOO_SMALL, caller);
}

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.

                                                                  {
    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 349 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 = (1UL<<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 335 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().

validateOneQubitDampingProb()

void validateOneQubitDampingProb	(	qreal	prob,
		const char *	caller
	)

Definition at line 578 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 563 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 573 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 610 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 588 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 477 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 523 of file QuEST_validation.c.

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

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.

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

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.

                                                              {
    validateHamilParams(hamil.numQubits, hamil.numSumTerms, caller);
    validatePauliCodes(hamil.pauliCodes, hamil.numSumTerms*hamil.numQubits, caller);
}

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.

                                                                                                    {
 
    QuESTAssert(
        funcCode == NORM || 
        funcCode == INVERSE_NORM ||
        funcCode == SCALED_NORM ||
        funcCode == SCALED_INVERSE_NORM ||
        funcCode == SCALED_INVERSE_SHIFTED_NORM ||
        funcCode == PRODUCT ||
        funcCode == INVERSE_PRODUCT ||
        funcCode == SCALED_PRODUCT ||
        funcCode == SCALED_INVERSE_PRODUCT ||
        funcCode == DISTANCE ||
        funcCode == INVERSE_DISTANCE ||
        funcCode == SCALED_DISTANCE ||
        funcCode == SCALED_INVERSE_DISTANCE ||
        funcCode == SCALED_INVERSE_SHIFTED_DISTANCE,
            E_INVALID_PHASE_FUNC_NAME, caller);
 
    if (funcCode == NORM || 
        funcCode == PRODUCT ||
        funcCode == DISTANCE)
            QuESTAssert(numParams == 0, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, caller);
            
    if (funcCode == INVERSE_NORM ||
        funcCode == INVERSE_PRODUCT ||
        funcCode == INVERSE_DISTANCE)
            QuESTAssert(numParams == 1, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, caller);
 
    if (funcCode == SCALED_NORM ||
        funcCode == SCALED_PRODUCT ||
        funcCode == SCALED_DISTANCE)
            QuESTAssert(numParams == 1, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, caller);
 
    if (funcCode == SCALED_INVERSE_NORM ||
        funcCode == SCALED_INVERSE_PRODUCT ||
        funcCode == SCALED_INVERSE_DISTANCE)
            QuESTAssert(numParams == 2, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, caller);
            
    if (funcCode == SCALED_INVERSE_SHIFTED_NORM)
        QuESTAssert(numParams == 2 + numRegs, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, caller);
 
    if (funcCode == SCALED_INVERSE_SHIFTED_DISTANCE)
        QuESTAssert(numParams == 2 + numRegs / 2, E_INVALID_NUM_NAMED_PHASE_FUNC_PARAMS, caller);
 
    if (funcCode == DISTANCE ||
        funcCode == INVERSE_DISTANCE ||
        funcCode == SCALED_DISTANCE ||
        funcCode == SCALED_INVERSE_DISTANCE ||
        funcCode == SCALED_INVERSE_SHIFTED_DISTANCE)
            QuESTAssert(numRegs%2 == 0, E_INVALID_NUM_REGS_DISTANCE_PHASE_FUNC, caller);
}

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.

                                                                                                                                                   {
    QuESTAssert(numOverrides>=0, E_INVALID_NUM_PHASE_FUNC_OVERRIDES, caller);
    QuESTAssert(numOverrides<=(1<<numQubits), E_INVALID_NUM_PHASE_FUNC_OVERRIDES, caller);
 
    long long int maxInd;
    long long int minInd;
 
    if (encoding == UNSIGNED) {
        minInd = 0;
        maxInd = (1LL << numQubits) - 1;
        for (int v=0; v<numOverrides; v++)
            QuESTAssert(overrideInds[v]>=minInd && overrideInds[v]<=maxInd, E_INVALID_PHASE_FUNC_OVERRIDE_UNSIGNED_INDEX, caller);
    }
 
    if (encoding == TWOS_COMPLEMENT) {
        int numValQubits = numQubits - 1; // removing sign bit
        minInd = - (1LL << numValQubits);
        maxInd = (1LL << numValQubits) - 1;
        for (int v=0; v<numOverrides; v++)
            QuESTAssert(overrideInds[v]>=minInd && overrideInds[v]<=maxInd, E_INVALID_PHASE_FUNC_OVERRIDE_TWOS_COMPLEMENT_INDEX, caller);
    }
 
}

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.

                                                                                                                                                                                        {
    QuESTAssert(numTerms>0, E_INVALID_NUM_PHASE_FUNC_TERMS, caller);
    
    int hasFractionExpo = 0;
    int hasNegativeExpo = 0;
    for (int t=0; t<numTerms; t++) {
        // this is only true if exponent is precisely an integer, else pow() will NaN
        if (floor(exponents[t]) != exponents[t])
            hasFractionExpo = 1;
        if (exponents[t] < 0)
            hasNegativeExpo = 1;
    }
    
    // ensure negative exponents are supplied along with a zero-index override
    if (hasNegativeExpo) {
        int hasZeroOverride = 0;
        for (int v=0; v<numOverrides; v++) {
            if (overrideInds[v] == 0LL) {
                hasZeroOverride = 1;
                break;
            }
        }
        QuESTAssert(hasZeroOverride, E_NEGATIVE_EXPONENT_WITHOUT_ZERO_OVERRIDE, caller);
    }
    
    // ensure fractional powers not used with negative numbers, unless overriden
    if (hasFractionExpo && encoding == TWOS_COMPLEMENT) {
        long long int numNegInds = (1LL << (numQubits-1));
        
        // immediately disqualify if insufficient overrides are given to cover every negative number
        QuESTAssert(numOverrides >= numNegInds, E_FRACTIONAL_EXPONENT_WITHOUT_NEG_OVERRIDE, caller);
        
        int allNegsOverriden;
        
        // if there are 16 or fewer qubits (0.5mB cache), use a stack array to tick off overrides
        if (numQubits < 16) {
            
            // flags for {-1,-2,...}; at index {abs(-1)-1, abs(-2)-2, ...}
            long long int negIsOverriden[32768];  // [numNegInds];
            for (int i=0; i<numNegInds; i++)
                negIsOverriden[i] = 0;
            
            for (int v=0; v<numOverrides; v++)
                if (overrideInds[v] < 0)
                    negIsOverriden[ -1 - overrideInds[v] ] = 1;
            
            allNegsOverriden = 1;
            for (int i=0; i<numNegInds; i++) {
                if (!negIsOverriden[i]) {
                    allNegsOverriden = 0;
                    break;
                }
            }
        }
        // otherwise, we must trust the user, else impose significant slowdowns on good users
        else {
            allNegsOverriden = 1;
        }
            
        QuESTAssert(allNegsOverriden, E_FRACTIONAL_EXPONENT_WITHOUT_NEG_OVERRIDE, caller);
    }
}

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.

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

validateQubitSubregs()

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

Definition at line 757 of file QuEST_validation.c.

                                                                                                                 {
    QuESTAssert(numRegs>0 && numRegs<=MAX_NUM_REGS_APPLY_ARBITRARY_PHASE, E_INVALID_NUM_SUBREGISTERS, caller);
 
    int i=0;
    for (int r=0; r<numRegs; r++) {
        QuESTAssert(numQubitsPerReg[r]>0 && numQubitsPerReg[r]<=qureg.numQubitsRepresented, E_INVALID_NUM_QUBITS, caller);
 
        for (int q=0; q < numQubitsPerReg[r]; q++) {
            QuESTAssert(qubits[i]>=0 && qubits[i]<qureg.numQubitsRepresented, E_INVALID_QUBIT_INDEX, caller);
            i++;
        }
    }
 
    QuESTAssert(areUniqueQubits(qubits, i), E_QUBITS_NOT_UNIQUE, caller);
}

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.

                                                                   {
    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 377 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 515 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(), initStateOfSingleQubit(), and setAmps().

validateTarget()

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

Definition at line 400 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 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.

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

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.

                                                                 {
    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 583 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 622 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 481 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 414 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 507 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	vector,
		const char *	caller
	)

Definition at line 511 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().