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 ("multiplyPauliStr", TEST_CATEGORY)
	TEST_CASE ("multiplyPauliGadget", TEST_CATEGORY)
	TEST_CASE ("multiplyCompMatr1", TEST_CATEGORY)
	TEST_CASE ("multiplyCompMatr2", TEST_CATEGORY)
	TEST_CASE ("multiplyDiagMatr1", TEST_CATEGORY)
	TEST_CASE ("multiplyDiagMatr2", TEST_CATEGORY)
	TEST_CASE ("applyPhaseFlip", TEST_CATEGORY)
	TEST_CASE ("applyTwoQubitPhaseFlip", TEST_CATEGORY)
	TEST_CASE ("applyPhaseShift", TEST_CATEGORY)
	TEST_CASE ("applyTwoQubitPhaseShift", TEST_CATEGORY)
	TEST_CASE ("multiplyCompMatr", TEST_CATEGORY)
	TEST_CASE ("multiplyDiagMatr", TEST_CATEGORY)
	TEST_CASE ("multiplyDiagMatrPower", TEST_CATEGORY)
	TEST_CASE ("multiplyMultiQubitNot", TEST_CATEGORY)
	TEST_CASE ("multiplyPhaseGadget", TEST_CATEGORY)
	TEST_CASE ("applyMultiQubitPhaseFlip", TEST_CATEGORY)
	TEST_CASE ("applyMultiQubitPhaseShift", TEST_CATEGORY)
	TEST_CASE ("applyQuantumFourierTransform", TEST_CATEGORY)
	TEST_CASE ("applyFullQuantumFourierTransform", TEST_CATEGORY)
	TEST_CASE ("applyQubitProjector", TEST_CATEGORY)
	TEST_CASE ("applyMultiQubitProjector", TEST_CATEGORY)
	TEST_CASE ("applyForcedQubitMeasurement", TEST_CATEGORY)
	TEST_CASE ("applyForcedMultiQubitMeasurement", TEST_CATEGORY)
	TEST_CASE ("applyMultiQubitMeasurement", TEST_CATEGORY)
	TEST_CASE ("applyMultiQubitMeasurementAndGetProb", TEST_CATEGORY)
	TEST_CASE ("applyQubitMeasurement", TEST_CATEGORY)
	TEST_CASE ("applyQubitMeasurementAndGetProb", TEST_CATEGORY)
	TEST_CASE ("multiplyFullStateDiagMatr", TEST_CATEGORY LABEL_MIXED_DEPLOY_TAG)
	TEST_CASE ("multiplyFullStateDiagMatrPower", TEST_CATEGORY LABEL_MIXED_DEPLOY_TAG)
	TEST_CASE ("applyFullStateDiagMatr", TEST_CATEGORY LABEL_MIXED_DEPLOY_TAG)
	TEST_CASE ("applyFullStateDiagMatrPower", TEST_CATEGORY LABEL_MIXED_DEPLOY_TAG)
	TEST_CASE ("multiplyPauliStrSum", TEST_CATEGORY LABEL_MIXED_DEPLOY_TAG)

Detailed Description

Function Documentation

TEST_ALL_CTRL_OPERATIONS()

TEST_ALL_CTRL_OPERATIONS	(	PauliStr	,
		any	,
		paulistr	,
		nullptr	)

TESTS

TEST_CASE() [1/32]

TEST_CASE	(	"applyForcedMultiQubitMeasurement"	,
		TEST_CATEGORY	)

Definition at line 1534 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/32]

TEST_CASE	(	"applyForcedQubitMeasurement"	,
		TEST_CATEGORY	)

Definition at line 1495 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/32]

TEST_CASE	(	"applyFullQuantumFourierTransform"	,
		TEST_CATEGORY	)

Definition at line 1398 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/32]

TEST_CASE	(	"applyFullStateDiagMatr"	,
		TEST_CATEGORY	LABEL_MIXED_DEPLOY_TAG )

Definition at line 1806 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, TEST_NUM_MIXED_DEPLOYMENT_REPETITIONS) );
 
        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/32]

TEST_CASE	(	"applyFullStateDiagMatrPower"	,
		TEST_CATEGORY	LABEL_MIXED_DEPLOY_TAG )

Definition at line 1838 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, TEST_NUM_MIXED_DEPLOYMENT_REPETITIONS) );
 
        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/32]

TEST_CASE	(	"applyMultiQubitMeasurement"	,
		TEST_CATEGORY	)

Definition at line 1580 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/32]

TEST_CASE	(	"applyMultiQubitMeasurementAndGetProb"	,
		TEST_CATEGORY	)

Definition at line 1617 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/32]

TEST_CASE	(	"applyMultiQubitPhaseFlip"	,
		TEST_CATEGORY	)

Definition at line 1335 of file operations.cpp.

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

TEST_CASE() [9/32]

TEST_CASE	(	"applyMultiQubitPhaseShift"	,
		TEST_CATEGORY	)

Definition at line 1340 of file operations.cpp.

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

TEST_CASE() [10/32]

TEST_CASE	(	"applyMultiQubitProjector"	,
		TEST_CATEGORY	)

Definition at line 1469 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/32]

TEST_CASE	(	"applyPhaseFlip"	,
		TEST_CATEGORY	)

Definition at line 1297 of file operations.cpp.

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

TEST_CASE() [12/32]

TEST_CASE	(	"applyPhaseShift"	,
		TEST_CATEGORY	)

Definition at line 1299 of file operations.cpp.

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

TEST_CASE() [13/32]

TEST_CASE	(	"applyQuantumFourierTransform"	,
		TEST_CATEGORY	)

Definition at line 1350 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() [14/32]

TEST_CASE	(	"applyQubitMeasurement"	,
		TEST_CATEGORY	)

Definition at line 1656 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() [15/32]

TEST_CASE	(	"applyQubitMeasurementAndGetProb"	,
		TEST_CATEGORY	)

Definition at line 1692 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() [16/32]

TEST_CASE	(	"applyQubitProjector"	,
		TEST_CATEGORY	)

Definition at line 1443 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() [17/32]

TEST_CASE	(	"applyTwoQubitPhaseFlip"	,
		TEST_CATEGORY	)

Definition at line 1298 of file operations.cpp.

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

TEST_CASE() [18/32]

TEST_CASE	(	"applyTwoQubitPhaseShift"	,
		TEST_CATEGORY	)

Definition at line 1300 of file operations.cpp.

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

TEST_CASE() [19/32]

TEST_CASE	(	"multiplyCompMatr"	,
		TEST_CATEGORY	)

Definition at line 1310 of file operations.cpp.

                                                { 
    auto func = static_cast<void(*)(Qureg, int*, int, CompMatr)>(multiplyCompMatr);
    testOperation<zero,any,compmatr>(func, nullptr, true); 
}

TEST_CASE() [20/32]

TEST_CASE	(	"multiplyCompMatr1"	,
		TEST_CATEGORY	)

Definition at line 1293 of file operations.cpp.

{ testOperation<zero,one,compmatr>(multiplyCompMatr1,   nullptr, true); }

TEST_CASE() [21/32]

TEST_CASE	(	"multiplyCompMatr2"	,
		TEST_CATEGORY	)

Definition at line 1294 of file operations.cpp.

{ testOperation<zero,two,compmatr>(multiplyCompMatr2,   nullptr, true); }

TEST_CASE() [22/32]

TEST_CASE	(	"multiplyDiagMatr"	,
		TEST_CATEGORY	)

Definition at line 1315 of file operations.cpp.

                                                {
    auto func = static_cast<void(*)(Qureg, int*, int, DiagMatr)>(multiplyDiagMatr);
    testOperation<zero,any,diagmatr>(func, nullptr, true);
}

TEST_CASE() [23/32]

TEST_CASE	(	"multiplyDiagMatr1"	,
		TEST_CATEGORY	)

Definition at line 1295 of file operations.cpp.

{ testOperation<zero,one,diagmatr>(multiplyDiagMatr1,   nullptr, true); }

TEST_CASE() [24/32]

TEST_CASE	(	"multiplyDiagMatr2"	,
		TEST_CATEGORY	)

Definition at line 1296 of file operations.cpp.

{ testOperation<zero,two,diagmatr>(multiplyDiagMatr2,   nullptr, true); }

TEST_CASE() [25/32]

TEST_CASE	(	"multiplyDiagMatrPower"	,
		TEST_CATEGORY	)

Definition at line 1320 of file operations.cpp.

                                                     {
    auto func = static_cast<void(*)(Qureg, int*, int, DiagMatr, qcomp)>(multiplyDiagMatrPower);
    testOperation<zero,any,diagpower>(func, nullptr, true);
}

TEST_CASE() [26/32]

TEST_CASE	(	"multiplyFullStateDiagMatr"	,
		TEST_CATEGORY	LABEL_MIXED_DEPLOY_TAG )

Definition at line 1730 of file operations.cpp.

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

TEST_CASE() [27/32]

TEST_CASE	(	"multiplyFullStateDiagMatrPower"	,
		TEST_CATEGORY	LABEL_MIXED_DEPLOY_TAG )

Definition at line 1762 of file operations.cpp.

                                                                                    {
 
    PREPARE_TEST( numQubits, cachedSV, cachedDM, refSV, refDM );
 
    auto cachedMatrs = getCachedFullStateDiagMatrs();
 
    SECTION( LABEL_CORRECTNESS ) {
 
        qmatrix refMatr = getRandomDiagonalMatrix(getPow2(numQubits));
        qcomp exponent = getRandomComplex();
 
        auto apiFunc = [&](Qureg qureg, FullStateDiagMatr matr) { 
            return multiplyFullStateDiagMatrPower(qureg, matr, exponent);
        };
 
        CAPTURE( exponent );
        
        GENERATE( range(0, TEST_NUM_MIXED_DEPLOYMENT_REPETITIONS) );
 
        SECTION( LABEL_STATEVEC ) {
 
            auto refFunc = [&] (qvector& state, qmatrix matr) { 
                matr = getPowerOfDiagonalMatrix(matr, exponent);
                multiplyReferenceOperator(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);
                multiplyReferenceOperator(state, matr);
            };
 
            TEST_ON_CACHED_QUREG_AND_MATRIX( cachedDM, cachedMatrs, apiFunc, refDM, refMatr, refFunc);
        }
    }
 
    /// @todo input validation
}

TEST_CASE() [28/32]

TEST_CASE	(	"multiplyMultiQubitNot"	,
		TEST_CATEGORY	)

Definition at line 1325 of file operations.cpp.

                                                     {
    auto func = static_cast<void(*)(Qureg, int*, int)>(multiplyMultiQubitNot);
    testOperation<zero,any,none>(func, VariableSizeMatrices::X, true);
}

TEST_CASE() [29/32]

TEST_CASE	(	"multiplyPauliGadget"	,
		TEST_CATEGORY	)

Definition at line 1292 of file operations.cpp.

{ testOperation<zero,any,pauligad>(multiplyPauliGadget, nullptr, true); }

TEST_CASE() [30/32]

TEST_CASE	(	"multiplyPauliStr"	,
		TEST_CATEGORY	)

Definition at line 1291 of file operations.cpp.

{ testOperation<zero,any,paulistr>(multiplyPauliStr,    nullptr, true); }

TEST_CASE() [31/32]

TEST_CASE	(	"multiplyPauliStrSum"	,
		TEST_CATEGORY	LABEL_MIXED_DEPLOY_TAG )

Definition at line 1893 of file operations.cpp.

                                                                         {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numQubits = getNumCachedQubits();
        int numTerms = GENERATE_COPY( 1, 2, 10 );
 
        PauliStrSum sum = createRandomPauliStrSum(numQubits, numTerms);
 
        auto testFunc = [&](Qureg qureg, auto& ref) {
 
            // must use (and ergo make) an identically-deployed workspace
            Qureg workspace = createCloneQureg(qureg);
            multiplyPauliStrSum(qureg, sum, workspace);
            destroyQureg(workspace);
 
            ref = getMatrix(sum, numQubits) * ref;
        };
 
        CAPTURE( numTerms );
        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() [32/32]

TEST_CASE	(	"multiplyPhaseGadget"	,
		TEST_CATEGORY	)

Definition at line 1330 of file operations.cpp.

                                                   {
    auto func = static_cast<void(*)(Qureg, int*, int, qreal)>(multiplyPhaseGadget);
    testOperation<zero,any,scalar>(func, VariableSizeParameterisedMatrices::Z, true);
}