Operations

	TEST_ALL_CTRL_OPERATIONS (PauliStr, any, paulistr, nullptr)
	TEST_ALL_CTRL_OPERATIONS (PauliGadget, any, pauligad, nullptr)
	TEST_ALL_CTRL_OPERATIONS (CompMatr1, one, compmatr, nullptr)
	TEST_ALL_CTRL_OPERATIONS (CompMatr2, two, compmatr, nullptr)
	TEST_ALL_CTRL_OPERATIONS (CompMatr, any, compmatr, nullptr)
	TEST_ALL_CTRL_OPERATIONS (DiagMatr1, one, diagmatr, nullptr)
	TEST_ALL_CTRL_OPERATIONS (DiagMatr2, two, diagmatr, nullptr)
	TEST_ALL_CTRL_OPERATIONS (DiagMatr, any, diagmatr, nullptr)
	TEST_ALL_CTRL_OPERATIONS (DiagMatrPower, any, diagpower, nullptr)
	TEST_ALL_CTRL_OPERATIONS (Hadamard, one, none, FixedMatrices::H)
	TEST_ALL_CTRL_OPERATIONS (PauliX, one, none, FixedMatrices::X)
	TEST_ALL_CTRL_OPERATIONS (PauliY, one, none, FixedMatrices::Y)
	TEST_ALL_CTRL_OPERATIONS (PauliZ, one, none, FixedMatrices::Z)
	TEST_ALL_CTRL_OPERATIONS (T, one, none, FixedMatrices::T)
	TEST_ALL_CTRL_OPERATIONS (S, one, none, FixedMatrices::S)
	TEST_ALL_CTRL_OPERATIONS (Swap, two, none, FixedMatrices::SWAP)
	TEST_ALL_CTRL_OPERATIONS (SqrtSwap, two, none, FixedMatrices::sqrtSWAP)
	TEST_ALL_CTRL_OPERATIONS (RotateX, one, scalar, ParameterisedMatrices::Rx)
	TEST_ALL_CTRL_OPERATIONS (RotateY, one, scalar, ParameterisedMatrices::Ry)
	TEST_ALL_CTRL_OPERATIONS (RotateZ, one, scalar, ParameterisedMatrices::Rz)
	TEST_ALL_CTRL_OPERATIONS (RotateAroundAxis, one, axisrots, nullptr)
	TEST_ALL_CTRL_OPERATIONS (MultiQubitNot, any, none, VariableSizeMatrices::X)
	TEST_ALL_CTRL_OPERATIONS (PhaseGadget, any, scalar, VariableSizeParameterisedMatrices::Z)
	TEST_CASE ("applyPhaseFlip", TEST_CATEGORY_OPS)
	TEST_CASE ("applyTwoQubitPhaseFlip", TEST_CATEGORY_OPS)
	TEST_CASE ("applyPhaseShift", TEST_CATEGORY_OPS)
	TEST_CASE ("applyTwoQubitPhaseShift", TEST_CATEGORY_OPS)
	TEST_CASE ("applyMultiQubitPhaseFlip", TEST_CATEGORY_OPS)
	TEST_CASE ("applyMultiQubitPhaseShift", TEST_CATEGORY_OPS)
	TEST_CASE ("applyQuantumFourierTransform", TEST_CATEGORY_OPS)
	TEST_CASE ("applyFullQuantumFourierTransform", TEST_CATEGORY_OPS)
	TEST_CASE ("applyQubitProjector", TEST_CATEGORY_OPS)
	TEST_CASE ("applyMultiQubitProjector", TEST_CATEGORY_OPS)
	TEST_CASE ("applyForcedQubitMeasurement", TEST_CATEGORY_OPS)
	TEST_CASE ("applyForcedMultiQubitMeasurement", TEST_CATEGORY_OPS)
	TEST_CASE ("applyMultiQubitMeasurement", TEST_CATEGORY_OPS)
	TEST_CASE ("applyMultiQubitMeasurementAndGetProb", TEST_CATEGORY_OPS)
	TEST_CASE ("applyQubitMeasurement", TEST_CATEGORY_OPS)
	TEST_CASE ("applyQubitMeasurementAndGetProb", TEST_CATEGORY_OPS)
	TEST_CASE ("applyFullStateDiagMatr", TEST_CATEGORY_OPS LABEL_MIXED_DEPLOY_TAG)
	TEST_CASE ("applyFullStateDiagMatrPower", TEST_CATEGORY_OPS LABEL_MIXED_DEPLOY_TAG)
	TEST_CASE ("applyNonUnitaryPauliGadget", TEST_CATEGORY_OPS)

Detailed Description

Function Documentation

TEST_ALL_CTRL_OPERATIONS()

TEST_ALL_CTRL_OPERATIONS	(	PauliStr	,
		any	,
		paulistr	,
		nullptr	)

OPERATOR TESTS

TEST_CASE() [1/19]

TEST_CASE	(	"applyForcedMultiQubitMeasurement"	,
		TEST_CATEGORY_OPS	)

Definition at line 1549 of file operations.cpp.

                                                                   {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numTargs = GENERATE_COPY( range(1,numQubits+1) );
        auto targets = GENERATE_TARGS( numQubits, numTargs );
        auto outcomes = getRandomOutcomes(numTargs);
 
        qmatrix projector = getProjector(targets, outcomes, numQubits);
 
        // this test may randomly request a measurement outcome which
        // is illegally unlikely, triggering validation; we merely
        // disable such validation and hope divergences don't break the test!
        setValidationEpsilon(0);
 
        auto testFunc = [&](Qureg qureg, auto& ref) {
 
            // overwrite caller's setting of initDebugState, since
            // that precludes outcomes=|0><0| due to zero-probability
            setToRandomState(ref);
            setQuregToReference(qureg, ref);
 
            // compare the probabilities...
            qreal apiProb = applyForcedMultiQubitMeasurement(qureg, targets.data(), outcomes.data(), numTargs);
            qreal refProb = getReferenceProbability(ref, targets, outcomes);
            REQUIRE_AGREE( apiProb, refProb );
 
            // and the post-measurement states (caller calls subsequent REQUIRE_AGREE)
            applyReferenceOperator(ref, projector);
            ref /= (qureg.isDensityMatrix)?
                refProb : std::sqrt(refProb);
        };
 
        CAPTURE( targets, outcomes );
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(statevecQuregs, statevecRef, testFunc); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc); }
 
        setValidationEpsilonToDefault();
    }
 
    /// @todo input validation
}

TEST_CASE() [2/19]

TEST_CASE	(	"applyForcedQubitMeasurement"	,
		TEST_CATEGORY_OPS	)

Definition at line 1510 of file operations.cpp.

                                                              {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        GENERATE( range(0,10) );
        int target = GENERATE_COPY( range(0,numQubits) );
        int outcome = GENERATE( 0, 1 );
 
        qmatrix projector = getProjector(outcome);
 
        auto testFunc = [&](Qureg qureg, auto& ref) {
 
            // overwrite caller's setting of initDebugState, since
            // that precludes outcomes=|0><0| due to zero-probability
            setToRandomState(ref);
            setQuregToReference(qureg, ref);
 
            // compare the probabilities...
            qreal apiProb = applyForcedQubitMeasurement(qureg, target, outcome);
            qreal refProb = getReferenceProbability(ref, {target}, {outcome});
            REQUIRE_AGREE( apiProb, refProb );
 
            // and the post-projection states (caller calls subsequent REQUIRE_AGREE)
            applyReferenceOperator(ref, {target}, projector);
            ref /= (qureg.isDensityMatrix)?
                refProb : std::sqrt(refProb);
        };
 
        CAPTURE( target, outcome );
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(statevecQuregs, statevecRef, testFunc); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc); }
    }
 
    /// @todo input validation
}

TEST_CASE() [3/19]

TEST_CASE	(	"applyFullQuantumFourierTransform"	,
		TEST_CATEGORY_OPS	)

Definition at line 1413 of file operations.cpp.

                                                                   {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        GENERATE( range(0,10) );
 
        SECTION( LABEL_STATEVEC ) { 
 
            auto testFunc = [&](Qureg qureg, qvector& ref) {
                applyFullQuantumFourierTransform(qureg);
                ref = getDisceteFourierTransform(ref);
            };
 
            TEST_ON_CACHED_QUREGS(statevecQuregs, statevecRef, testFunc);
        }
 
        SECTION( LABEL_DENSMATR ) { 
 
            // prepare a random mixture
            auto states = getRandomOrthonormalStateVectors(numQubits, getRandomInt(1,10));
            auto probs = getRandomProbabilities(states.size());
 
            auto testFunc = [&](Qureg qureg, qmatrix& ref) {
 
                // overwrite the Qureg debug state set by caller to above mixture
                setQuregToReference(qureg, getMixture(states, probs));
                applyFullQuantumFourierTransform(qureg);
                
                ref = getZeroMatrix(ref.size());
                for (size_t i=0; i<states.size(); i++) {
                    qvector vec = getDisceteFourierTransform(states[i]);
                    ref += probs[i] * getOuterProduct(vec, vec);
                }
            };
 
            TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc);
        }
    }
 
    /// @todo input validation
}

TEST_CASE() [4/19]

TEST_CASE	(	"applyFullStateDiagMatr"	,
		TEST_CATEGORY_OPS	LABEL_MIXED_DEPLOY_TAG )

Definition at line 1745 of file operations.cpp.

                                                                                {
 
    PREPARE_TEST( numQubits, cachedSV, cachedDM, refSV, refDM );
 
    auto cachedMatrs = getCachedFullStateDiagMatrs();
 
    SECTION( LABEL_CORRECTNESS ) {
 
        qmatrix refMatr = getRandomDiagonalUnitary(numQubits);
        auto apiFunc = applyFullStateDiagMatr;
 
        GENERATE( range(0, getNumTestedMixedDeploymentRepetitions()) );
 
        SECTION( LABEL_STATEVEC ) {
 
            auto refFunc = [&] (qvector& state, qmatrix matr) { applyReferenceOperator(state, matr); };
 
            TEST_ON_CACHED_QUREG_AND_MATRIX( cachedSV, cachedMatrs, apiFunc, refSV, refMatr, refFunc);
        }
 
        SECTION( LABEL_DENSMATR ) {
 
            auto refFunc = [&] (qmatrix& state, qmatrix matr) { applyReferenceOperator(state, matr); };
 
            TEST_ON_CACHED_QUREG_AND_MATRIX( cachedDM, cachedMatrs, apiFunc, refDM, refMatr, refFunc);
        }
    }
 
    /// @todo input validation
}

TEST_CASE() [5/19]

TEST_CASE	(	"applyFullStateDiagMatrPower"	,
		TEST_CATEGORY_OPS	LABEL_MIXED_DEPLOY_TAG )

Definition at line 1777 of file operations.cpp.

                                                                                     {
 
    PREPARE_TEST( numQubits, cachedSV, cachedDM, refSV, refDM );
 
    auto cachedMatrs = getCachedFullStateDiagMatrs();
 
    SECTION( LABEL_CORRECTNESS ) {
 
        qmatrix refMatr = getRandomDiagonalUnitary(numQubits);
 
        // supplying a complex exponent requires disabling
        // numerical validation to relax unitarity
        bool testRealExp = GENERATE( true, false );
        qcomp exponent = (testRealExp)?
            qcomp(getRandomReal(-2, 2), 0):
            getRandomComplex();
 
        auto apiFunc = [&](Qureg qureg, FullStateDiagMatr matr) { 
            return applyFullStateDiagMatrPower(qureg, matr, exponent);
        };
 
        CAPTURE( exponent );
 
        GENERATE( range(0, getNumTestedMixedDeploymentRepetitions()) );
 
        if (!testRealExp)
            setValidationEpsilon(0);
 
        SECTION( LABEL_STATEVEC ) {
 
            auto refFunc = [&] (qvector& state, qmatrix matr) { 
                matr = getPowerOfDiagonalMatrix(matr, exponent);
                applyReferenceOperator(state, matr);
            };
 
            TEST_ON_CACHED_QUREG_AND_MATRIX( cachedSV, cachedMatrs, apiFunc, refSV, refMatr, refFunc);
        }
 
        SECTION( LABEL_DENSMATR ) {
 
            auto refFunc = [&] (qmatrix& state, qmatrix matr) { 
                matr = getPowerOfDiagonalMatrix(matr, exponent);
                applyReferenceOperator(state, matr);
            };
 
            TEST_ON_CACHED_QUREG_AND_MATRIX( cachedDM, cachedMatrs, apiFunc, refDM, refMatr, refFunc);
        }
 
        setValidationEpsilonToDefault();
    }
 
    /// @todo input validation
}

TEST_CASE() [6/19]

TEST_CASE	(	"applyMultiQubitMeasurement"	,
		TEST_CATEGORY_OPS	)

Definition at line 1595 of file operations.cpp.

                                                             {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numTargs = GENERATE_COPY( range(1,numQubits+1) );
        auto targets = GENERATE_TARGS( numQubits, numTargs );
 
        auto testFunc = [&](Qureg qureg, auto& ref) {
 
            // overwrite caller's setting of initDebugState, since
            // sampling requires the outcome probs are normalised
            setToRandomState(ref);
            setQuregToReference(qureg, ref);
            
            // the output API state...
            qindex apiOut = applyMultiQubitMeasurement(qureg, targets.data(), numTargs);
 
            // informs the projector which determines the post-measurement reference
            auto apiOutBits = getBits(apiOut, numTargs);
            qmatrix projector = getProjector(targets, apiOutBits, numQubits);
            applyReferenceOperator(ref, projector);
            qreal refProb = getReferenceProbability(ref, targets, apiOutBits);
            ref /= (qureg.isDensityMatrix)?
                refProb : std::sqrt(refProb);
        };
 
        CAPTURE( targets );
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(statevecQuregs, statevecRef, testFunc); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc); }
    }
 
    /// @todo input validation
}

TEST_CASE() [7/19]

TEST_CASE	(	"applyMultiQubitMeasurementAndGetProb"	,
		TEST_CATEGORY_OPS	)

Definition at line 1632 of file operations.cpp.

                                                                       {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numTargs = GENERATE_COPY( range(1,numQubits+1) );
        auto targets = GENERATE_TARGS( numQubits, numTargs );
 
        auto testFunc = [&](Qureg qureg, auto& ref) {
 
            // overwrite caller's setting of initDebugState, since
            // sampling requires the outcome probs are normalised
            setToRandomState(ref);
            setQuregToReference(qureg, ref);
 
            // compare the measurement probability...
            qreal apiProb = -1;
            qindex apiOut = applyMultiQubitMeasurementAndGetProb(qureg, targets.data(), numTargs, &apiProb);
            auto apiOutBits = getBits(apiOut, numTargs);
            qreal refProb = getReferenceProbability(ref, targets, apiOutBits);
            REQUIRE_AGREE( apiProb, refProb );
            
            // and the post-measurement states (caller calls subsequent REQUIRE_AGREE)
            qmatrix projector = getProjector(targets, apiOutBits, numQubits);
            applyReferenceOperator(ref, projector);
            ref /= (qureg.isDensityMatrix)?
                refProb : std::sqrt(refProb);
        };
 
        CAPTURE( targets );
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(statevecQuregs, statevecRef, testFunc); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc); }
    }
 
    /// @todo input validation
}

TEST_CASE() [8/19]

TEST_CASE	(	"applyMultiQubitPhaseFlip"	,
		TEST_CATEGORY_OPS	)

Definition at line 1350 of file operations.cpp.

                                                            {
    auto func = static_cast<void(*)(Qureg, int*, int)>(applyMultiQubitPhaseFlip);
    testOperation<zero,any,none,apply>(func, VariableSizeMatrices::PF);
}

TEST_CASE() [9/19]

TEST_CASE	(	"applyMultiQubitPhaseShift"	,
		TEST_CATEGORY_OPS	)

Definition at line 1355 of file operations.cpp.

                                                             {
    auto func = static_cast<void(*)(Qureg, int*, int, qreal)>(applyMultiQubitPhaseShift);
    testOperation<zero,any,scalar,apply>(func, VariableSizeParameterisedMatrices::PS);
}

TEST_CASE() [10/19]

TEST_CASE	(	"applyMultiQubitProjector"	,
		TEST_CATEGORY_OPS	)

Definition at line 1484 of file operations.cpp.

                                                           {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numTargs = GENERATE_COPY( range(1,numQubits+1) );
        auto targets = GENERATE_TARGS( numQubits, numTargs );
        auto outcomes = getRandomOutcomes(numTargs);
 
        qmatrix projector = getProjector(targets, outcomes, numQubits);
 
        auto testFunc = [&](Qureg qureg, auto& ref) {
            applyMultiQubitProjector(qureg, targets.data(), outcomes.data(), numTargs);
            applyReferenceOperator(ref, projector);
        };
 
        CAPTURE( targets, outcomes );
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(statevecQuregs, statevecRef, testFunc); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc); }
    }
 
    /// @todo input validation
}

TEST_CASE() [11/19]

TEST_CASE	(	"applyNonUnitaryPauliGadget"	,
		TEST_CATEGORY_OPS	)

Definition at line 1832 of file operations.cpp.

                                                             {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        // prepare a random Pauli string and angle
        int numTargs = GENERATE_COPY( range(1, numQubits+1) );
        auto targs = GENERATE_TARGS( numQubits, numTargs );
        PauliStr str = getRandomPauliStr(targs);
        qcomp angle = getRandomComplex();
 
        // prepare the corresponding reference matrix exp(-i angle pauli)
        auto matrRef = getExponentialOfPauliMatrix(angle, getMatrix(str, numQubits));
 
        auto testFunc = [&](Qureg qureg, auto& stateRef) {
            applyNonUnitaryPauliGadget(qureg, str, angle);
            applyReferenceOperator(stateRef, matrRef);
        };
 
        CAPTURE( targs, angle );
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(statevecQuregs, statevecRef, testFunc); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc); }
    }
 
    /// @todo input validation
}

TEST_CASE() [12/19]

TEST_CASE	(	"applyPhaseFlip"	,
		TEST_CATEGORY_OPS	)

Definition at line 1337 of file operations.cpp.

{ testOperation<zero,one,none,apply>  (applyPhaseFlip,          VariableSizeMatrices::PF(1)); }

TEST_CASE() [13/19]

TEST_CASE	(	"applyPhaseShift"	,
		TEST_CATEGORY_OPS	)

Definition at line 1339 of file operations.cpp.

{ testOperation<zero,one,scalar,apply>(applyPhaseShift,         ParameterisedMatrices::PS  ); }

TEST_CASE() [14/19]

TEST_CASE	(	"applyQuantumFourierTransform"	,
		TEST_CATEGORY_OPS	)

Definition at line 1365 of file operations.cpp.

                                                               {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numTargs = GENERATE_COPY( range(1,numQubits+1) );
        auto targs = GENERATE_TARGS( numQubits, numTargs );
 
        CAPTURE( targs );
 
        SECTION( LABEL_STATEVEC ) { 
 
            auto testFunc = [&](Qureg qureg, qvector& ref) {
                applyQuantumFourierTransform(qureg, targs.data(), targs.size());
                ref = getDisceteFourierTransform(ref, targs);
            };
 
            TEST_ON_CACHED_QUREGS(statevecQuregs, statevecRef, testFunc);
        }
 
        SECTION( LABEL_DENSMATR ) { 
 
            // prepare a random mixture
            auto states = getRandomOrthonormalStateVectors(numQubits, getRandomInt(1,10));
            auto probs = getRandomProbabilities(states.size());
 
            auto testFunc = [&](Qureg qureg, qmatrix& ref) {
 
                // overwrite the Qureg debug state set by caller to above mixture
                setQuregToReference(qureg, getMixture(states, probs));
                applyQuantumFourierTransform(qureg, targs.data(), targs.size());
                
                ref = getZeroMatrix(ref.size());
                for (size_t i=0; i<states.size(); i++) {
                    qvector vec = getDisceteFourierTransform(states[i], targs);
                    ref += probs[i] * getOuterProduct(vec, vec);
                }
            };
 
            TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc);
        }
    }
 
    /// @todo input validation
}

TEST_CASE() [15/19]

TEST_CASE	(	"applyQubitMeasurement"	,
		TEST_CATEGORY_OPS	)

Definition at line 1671 of file operations.cpp.

                                                        {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        GENERATE( range(0,10) );
        int target = GENERATE_COPY( range(0,numQubits) );
 
        auto testFunc = [&](Qureg qureg, auto& ref) {
 
            // overwrite caller's setting of initDebugState, since
            // sampling requires the outcome probs are normalised
            setToRandomState(ref);
            setQuregToReference(qureg, ref);
 
            // the output API state...
            int apiOut = applyQubitMeasurement(qureg, target);
 
            // informs the projector which determines the post-measurement reference
            qmatrix projector = getProjector(apiOut);
            applyReferenceOperator(ref, {target}, projector);
            qreal refProb = getReferenceProbability(ref, {target}, {apiOut});
            ref /= (qureg.isDensityMatrix)?
                refProb : std::sqrt(refProb);
        };
 
        CAPTURE( target );
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(statevecQuregs, statevecRef, testFunc); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc); }
    }
 
    /// @todo input validation
}

TEST_CASE() [16/19]

TEST_CASE	(	"applyQubitMeasurementAndGetProb"	,
		TEST_CATEGORY_OPS	)

Definition at line 1707 of file operations.cpp.

                                                                  {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        GENERATE( range(0,10) );
        int target = GENERATE_COPY( range(0,numQubits) );
 
        auto testFunc = [&](Qureg qureg, auto& ref) {
 
            // overwrite caller's setting of initDebugState, since
            // sampling requires the outcome probs are normalised
            setToRandomState(ref);
            setQuregToReference(qureg, ref);
 
            // compare the measurement probability...
            qreal apiProb = -1;
            int apiOut = applyQubitMeasurementAndGetProb(qureg, target, &apiProb);
            qreal refProb = getReferenceProbability(ref, {target}, {apiOut});
            REQUIRE_AGREE( apiProb, refProb );
            
            // and the post-measurement states (caller calls subsequent REQUIRE_AGREE)
            qmatrix projector = getProjector(apiOut);
            applyReferenceOperator(ref, {target}, projector);
            ref /= (qureg.isDensityMatrix)?
                refProb : std::sqrt(refProb);            
        };
 
        CAPTURE( target );
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(statevecQuregs, statevecRef, testFunc); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc); }
    }
 
    /// @todo input validation
}

TEST_CASE() [17/19]

TEST_CASE	(	"applyQubitProjector"	,
		TEST_CATEGORY_OPS	)

Definition at line 1458 of file operations.cpp.

                                                      {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        GENERATE( range(0,10) );
        int target = GENERATE_COPY( range(0,numQubits) );
        int outcome = GENERATE( 0, 1 );
 
        qmatrix projector = getProjector(outcome);
 
        auto testFunc = [&](Qureg qureg, auto& ref) {
            applyQubitProjector(qureg, target, outcome);
            applyReferenceOperator(ref, {target}, projector);
        };
 
        CAPTURE( target, outcome );
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(statevecQuregs, statevecRef, testFunc); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc); }
    }
 
    /// @todo input validation
}

TEST_CASE() [18/19]

TEST_CASE	(	"applyTwoQubitPhaseFlip"	,
		TEST_CATEGORY_OPS	)

Definition at line 1338 of file operations.cpp.

{ testOperation<zero,two,none,apply>  (applyTwoQubitPhaseFlip,  VariableSizeMatrices::PF(2)); }

TEST_CASE() [19/19]

TEST_CASE	(	"applyTwoQubitPhaseShift"	,
		TEST_CATEGORY_OPS	)

Definition at line 1340 of file operations.cpp.

{ testOperation<zero,two,scalar,apply>(applyTwoQubitPhaseShift, ParameterisedMatrices::PS2 ); }