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 1794 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!
        setQuESTValidationEpsilon(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); }
 
        setQuESTValidationEpsilonToDefault();
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        Qureg qureg = getArbitraryCachedStatevec();
        int targets[] = {0, 1, 2};
        int outcomes[] = {0, 1, 0};
        int numTargets = 3;
 
        // below validation tests assume the above parameters are valid (not impossibly unlikely)
        initDebugState(qureg);
        REQUIRE( calcProbOfMultiQubitOutcome(qureg, targets, outcomes, numTargets) > getQuESTValidationEpsilon() );
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            REQUIRE_THROWS_WITH(
                applyForcedMultiQubitMeasurement(badQureg, targets, outcomes, numTargets),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        SECTION( "invalid target qubits" ) {
 
            int badTargets[] = {0, 1, GENERATE_COPY( -1, qureg.numQubits )};
            REQUIRE_THROWS_WITH(
                applyForcedMultiQubitMeasurement(qureg, badTargets, outcomes, numTargets),
                ContainsSubstring("target")
            );
        }
 
        SECTION( "duplicate target qubits" ) {
            
            int dupTargets[] = {0, 1, 1};
            REQUIRE_THROWS_WITH(
                applyForcedMultiQubitMeasurement(qureg, dupTargets, outcomes, numTargets),
                ContainsSubstring("duplicate")
            );
        }
 
        SECTION( "invalid number of targets" ) {
            
            int badNumTargs = GENERATE( -1, 0 );
            REQUIRE_THROWS_WITH(
                applyForcedMultiQubitMeasurement(qureg, targets, outcomes, badNumTargs),
                ContainsSubstring("targets")
            );
 
            badNumTargs = qureg.numQubits + 1;
            REQUIRE_THROWS_WITH(
                applyForcedMultiQubitMeasurement(qureg, targets, outcomes, badNumTargs),
                ContainsSubstring("exceeds the number of qubits in the Qureg")
            );
        }
 
        SECTION( "invalid outcomes" ) {
 
            int badOutcomes[] = {0, 1, GENERATE( -1, 2 )};
            REQUIRE_THROWS_WITH(
                applyForcedMultiQubitMeasurement(qureg, targets, badOutcomes, numTargets),
                ContainsSubstring("outcome")
            );
        }
 
        SECTION( "improbable outcomes" ) {
 
            // impossible outcome
            initZeroState(qureg);
            int badOutcomes[] = {0, 0, 1};
            REQUIRE_THROWS_WITH(
                applyForcedMultiQubitMeasurement(qureg, targets, badOutcomes, numTargets),
                ContainsSubstring("impossibly unlikely")
            );
 
            // outcome of non-zero probability smaller than epsilon
            qreal badTheta = 1E-8;
            applyRotateX(qureg, targets[2], badTheta);
            REQUIRE_THROWS_WITH(
                applyForcedMultiQubitMeasurement(qureg, targets, badOutcomes, numTargets),
                ContainsSubstring("impossibly unlikely")
            );
 
            // confirm that >epsilon probability is fine
            initZeroState(qureg);
            qreal goodTheta = 0.1;
            applyRotateX(qureg, targets[2], goodTheta);
            int goodOutcomes[] = {0, 0, 1};
            REQUIRE( 
                calcProbOfMultiQubitOutcome(qureg, targets, goodOutcomes, numTargets) > getQuESTValidationEpsilon() 
            );
            REQUIRE_NOTHROW(
                applyForcedMultiQubitMeasurement(qureg, targets, goodOutcomes, numTargets)
            );
 
            // restore qureg state
            initDebugState(qureg);
        }
 
        SECTION( "targets mismatch outcomes (C++ only)") {
 
            REQUIRE_THROWS_WITH(
                applyForcedMultiQubitMeasurement(qureg, {0,1}, {0,1,1}),
                ContainsSubstring("inconsistent")
            );
        }
    }
}

TEST_CASE() [2/19]

TEST_CASE	(	"applyForcedQubitMeasurement"	,
		TEST_CATEGORY_OPS	)

Definition at line 1685 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); }
    }
 
    SECTION( LABEL_VALIDATION ) {
        
        Qureg qureg = getArbitraryCachedStatevec();
 
        // below validation tests assume qubit 0 can collapse to either outcome
        // (which does not require normalisation; qureg can be in the debug state)
        initDebugState(qureg);
        REQUIRE( calcProbOfQubitOutcome(qureg, 0, 0) > getQuESTValidationEpsilon() );
        REQUIRE( calcProbOfQubitOutcome(qureg, 0, 1) > getQuESTValidationEpsilon() );
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            REQUIRE_THROWS_WITH(
                applyForcedQubitMeasurement(badQureg, 0, 0),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        SECTION( "invalid target qubit" ) {
 
            int badTarget = GENERATE_COPY( -1, qureg.numQubits );
            REQUIRE_THROWS_WITH(
                applyForcedQubitMeasurement(qureg, badTarget, 0),
                ContainsSubstring("target")
            );
        }
 
        SECTION( "invalid outcome" ) {
 
            int badOutcome = GENERATE_COPY( -1, 2 );
            REQUIRE_THROWS_WITH(
                applyForcedQubitMeasurement(qureg, 0, badOutcome),
                ContainsSubstring("outcome")
            );
        }
 
        SECTION( "improbable outcome" ) {
 
            // precisely zero probability outcome
            initZeroState(qureg);
            int badOutcome = 1; // impossible
            REQUIRE_THROWS_WITH(
                applyForcedQubitMeasurement(qureg, 0, badOutcome),
                ContainsSubstring("impossibly unlikely")
            );
 
            // outcome of non-zero probability smaller than epsilon
            qreal badTheta = 1E-8;
            applyRotateX(qureg, 0, badTheta); // causes prob(1) = sin^2(theta) ~ 2.5E-17
            REQUIRE_THROWS_WITH(
                applyForcedQubitMeasurement(qureg, 0, badOutcome),
                ContainsSubstring("impossibly unlikely")
            );
 
            // confirm that >epsilon probability is fine
            initZeroState(qureg);
            qreal goodTheta = 0.1;
            applyRotateX(qureg, 0, goodTheta);
            REQUIRE( 
                calcProbOfQubitOutcome(qureg, 0, badOutcome) > getQuESTValidationEpsilon() 
            );
            REQUIRE_NOTHROW(
                applyForcedQubitMeasurement(qureg, 0, badOutcome)
            );
 
            // restore qureg state
            initDebugState(qureg);
        }
    }
}

TEST_CASE() [3/19]

TEST_CASE	(	"applyFullQuantumFourierTransform"	,
		TEST_CATEGORY_OPS	)

Definition at line 1470 of file operations.cpp.

                                                                   {
 
    PREPARE_TEST( numQubits, statevecQuregs, densmatrQuregs, statevecRef, densmatrRef );
 
    SECTION( LABEL_CORRECTNESS ) {
 
        GENERATE( range(0,10) );
        bool inverse = GENERATE(false, true);
 
        SECTION( LABEL_STATEVEC ) { 
 
            auto testFunc = [&](Qureg qureg, qvector& ref) {
                applyFullQuantumFourierTransform(qureg, inverse);
                ref = getDiscreteFourierTransform(ref, inverse);
            };
 
            CAPTURE(inverse);
            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, inverse);
                
                ref = getZeroMatrix(ref.size());
                for (size_t i=0; i<states.size(); i++) {
                    qvector vec = getDiscreteFourierTransform(states[i], inverse);
                    ref += probs[i] * getOuterProduct(vec, vec);
                }
            };
 
            CAPTURE(inverse);
            TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc);
        }
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        Qureg qureg = getArbitraryCachedStatevec();
        bool inverse = false;
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            REQUIRE_THROWS_WITH(
                applyFullQuantumFourierTransform(badQureg, inverse),
                ContainsSubstring("invalid Qureg")
            );
        }
    }
}

TEST_CASE() [4/19]

TEST_CASE	(	"applyFullStateDiagMatr"	,
		TEST_CATEGORY_OPS	LABEL_MIXED_DEPLOY_TAG )

Definition at line 2236 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 2268 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)
            setQuESTValidationEpsilon(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);
        }
 
        setQuESTValidationEpsilonToDefault();
    }
 
    /// @todo input validation
}

TEST_CASE() [6/19]

TEST_CASE	(	"applyMultiQubitMeasurement"	,
		TEST_CATEGORY_OPS	)

Definition at line 1944 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); }
    }
 
    SECTION( LABEL_VALIDATION ) {
        
        Qureg qureg = getArbitraryCachedStatevec();
        int targets[] = {0, 1, 2};
        int numTargets = 3;
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            REQUIRE_THROWS_WITH(
                applyMultiQubitMeasurement(badQureg, targets, numTargets),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        SECTION( "invalid target qubits" ) {
 
            int badTargets[] = {0, 1, GENERATE_COPY(-1, qureg.numQubits)};
            REQUIRE_THROWS_WITH(
                applyMultiQubitMeasurement(qureg, badTargets, numTargets),
                ContainsSubstring("target")
            );
        }
 
        SECTION( "duplicate target qubits" ) {
            
            int dupTargets[] = {0, 1, 1};
            REQUIRE_THROWS_WITH(
                applyMultiQubitMeasurement(qureg, dupTargets, numTargets),
                ContainsSubstring("duplicate")
            );
        }
 
        SECTION( "invalid number of targets" ) {
            
            int badNumTargs = GENERATE( -1, 0 );
            REQUIRE_THROWS_WITH(
                applyMultiQubitMeasurement(qureg, targets, badNumTargs),
                ContainsSubstring("targets")
            );
 
            badNumTargs = qureg.numQubits + 1;
            REQUIRE_THROWS_WITH(
                applyMultiQubitMeasurement(qureg, targets, badNumTargs),
                ContainsSubstring("exceeds the number of qubits in the Qureg")
            );
        }
    }
}

TEST_CASE() [7/19]

TEST_CASE	(	"applyMultiQubitMeasurementAndGetProb"	,
		TEST_CATEGORY_OPS	)

Definition at line 2029 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); }
    }
 
    SECTION( LABEL_VALIDATION ) {
        
        Qureg qureg = getArbitraryCachedStatevec();
        int targets[] = {0, 1, 2};
        int numTargets = 3;
        qreal outProb = 0;
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            REQUIRE_THROWS_WITH(
                applyMultiQubitMeasurementAndGetProb(badQureg, targets, numTargets, nullptr),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        SECTION( "invalid target qubits" ) {
 
            int badTargets[] = {0, 1, GENERATE_COPY( -1, qureg.numQubits )};
            REQUIRE_THROWS_WITH(
                applyMultiQubitMeasurementAndGetProb(qureg, badTargets, numTargets, &outProb),
                ContainsSubstring("target")
            );
        }
 
        SECTION( "duplicate target qubits" ) {
            
            int dupTargets[] = {0, 1, 1};
            REQUIRE_THROWS_WITH(
                applyMultiQubitMeasurementAndGetProb(qureg, dupTargets, numTargets, &outProb),
                ContainsSubstring("duplicate")
            );
        }
 
        SECTION( "invalid number of targets" ) {
            
            int badNumTargs = GENERATE( -1, 0 );
            REQUIRE_THROWS_WITH(
                applyMultiQubitMeasurementAndGetProb(qureg, targets, badNumTargs, &outProb),
                ContainsSubstring("targets")
            );
 
            badNumTargs = qureg.numQubits + 1;
            REQUIRE_THROWS_WITH(
                applyMultiQubitMeasurementAndGetProb(qureg, targets, badNumTargs, &outProb),
                ContainsSubstring("exceeds the number of qubits in the Qureg")
            );
        }
    }
}

TEST_CASE() [8/19]

TEST_CASE	(	"applyMultiQubitPhaseFlip"	,
		TEST_CATEGORY_OPS	)

Definition at line 1355 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 1360 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 1591 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); }
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        Qureg qureg = getArbitraryCachedStatevec();
        int targets[] = {0, 1, 2};
        int outcomes[] = {0, 1, 0};
        int numTargets = 3;
 
        SECTION( "qureg uninitialised" ) {
            
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            REQUIRE_THROWS_WITH(
                applyMultiQubitProjector(badQureg, targets, outcomes, numTargets),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        SECTION( "invalid target qubits" ) {
 
            int badTargets[] = {0, 1, GENERATE_COPY( -1, qureg.numQubits) };
            REQUIRE_THROWS_WITH(
                applyMultiQubitProjector(qureg, badTargets, outcomes, numTargets),
                ContainsSubstring("target")
            );
        }
 
        SECTION( "duplicate target qubits" ) {
 
            int dupTargets[] = {0, 1, 1};
            REQUIRE_THROWS_WITH(
                applyMultiQubitProjector(qureg, dupTargets, outcomes, numTargets),
                ContainsSubstring("duplicate")
            );
        }
 
        SECTION( "invalid number of targets" ) {
            
            int badNumTargs = GENERATE( 0, -1 );
            REQUIRE_THROWS_WITH(
                applyMultiQubitProjector(qureg, targets, outcomes, badNumTargs),
                ContainsSubstring("targets")
            );
 
            badNumTargs = qureg.numQubits + 1;
            REQUIRE_THROWS_WITH(
                applyMultiQubitProjector(qureg, targets, outcomes, badNumTargs),
                ContainsSubstring("exceeds the number of qubits in the Qureg")
            );
        }
 
        SECTION( "invalid outcomes" ) {
 
            int badOutcomes[] = {0, 1, GENERATE( -1, 2 ) };
            REQUIRE_THROWS_WITH(
                applyMultiQubitProjector(qureg, targets, badOutcomes, numTargets),
                ContainsSubstring("outcome")
            );
        }
 
        SECTION( "targets mismatch outcomes (C++ only)" ) {
 
            REQUIRE_THROWS_WITH(
                applyMultiQubitProjector(qureg, {0,1,2}, {0,1}),
                ContainsSubstring("outcomes") && ContainsSubstring("inconsistent with the given number of qubits")
            );
        }
 
        // projector does NOT validate outcome probability
    }
}

TEST_CASE() [11/19]

TEST_CASE	(	"applyNonUnitaryPauliGadget"	,
		TEST_CATEGORY_OPS	)

Definition at line 2323 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); }
    }
 
    SECTION( LABEL_VALIDATION ) {
        
        Qureg qureg = getArbitraryCachedStatevec();
        PauliStr str = getPauliStr("XY", {0, 1});
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            REQUIRE_THROWS_WITH(
                applyNonUnitaryPauliGadget(badQureg, str, qcomp(0.5, 0)),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        /// @todo remaining input validation
    }
}

TEST_CASE() [12/19]

TEST_CASE	(	"applyPhaseFlip"	,
		TEST_CATEGORY_OPS	)

Definition at line 1342 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 1344 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 1370 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 );
        bool inverse = GENERATE(false, true);
 
        CAPTURE( targs );
 
        SECTION( LABEL_STATEVEC ) { 
 
            auto testFunc = [&](Qureg qureg, qvector& ref) {
                applyQuantumFourierTransform(qureg, targs.data(), targs.size(), inverse);
                ref = getDiscreteFourierTransform(ref, targs, inverse);
            };
 
            CAPTURE(inverse);
            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(), inverse);
                
                ref = getZeroMatrix(ref.size());
                for (size_t i=0; i<states.size(); i++) {
                    qvector vec = getDiscreteFourierTransform(states[i], targs, inverse);
                    ref += probs[i] * getOuterProduct(vec, vec);
                }
            };
 
            CAPTURE(inverse);
            TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc);
        }
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        Qureg qureg = getArbitraryCachedStatevec();
        int targs[] = {0, 1, 2};
        int numTargs = 3;
        bool inverse = false;
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            REQUIRE_THROWS_WITH(
                applyQuantumFourierTransform(badQureg, targs, numTargs, inverse),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        SECTION( "invalid target qubits" ) {
 
            int badTargs[] = {0, 1, qureg.numQubits}; // latter is too large
            REQUIRE_THROWS_WITH(
                applyQuantumFourierTransform(qureg, badTargs, 3, inverse),
                ContainsSubstring("target")
            );
        }
 
        SECTION( "duplicate target qubits" ) {
 
            int dupTargs[] = {0, 1, 1};
            REQUIRE_THROWS_WITH(
                applyQuantumFourierTransform(qureg, dupTargs, 3, inverse),
                ContainsSubstring("duplicate")
            );
        }
 
        SECTION( "invalid number of targets" ) {
 
            int badNumTargs = GENERATE_COPY( -1, 0 ); 
            REQUIRE_THROWS_WITH(
                applyQuantumFourierTransform(qureg, targs, badNumTargs, inverse),
                ContainsSubstring("targets") || ContainsSubstring("target qubits")
            );
 
            badNumTargs = qureg.numQubits+1;
            REQUIRE_THROWS_WITH(
                applyQuantumFourierTransform(qureg, targs, badNumTargs, inverse),
                ContainsSubstring("exceeds the number of qubits in the Qureg")
            );
        }
    }
}

TEST_CASE() [15/19]

TEST_CASE	(	"applyQubitMeasurement"	,
		TEST_CATEGORY_OPS	)

Definition at line 2117 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); }
    }
 
    SECTION( LABEL_VALIDATION ) {
        
        Qureg qureg = getArbitraryCachedStatevec();
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            REQUIRE_THROWS_WITH(
                applyQubitMeasurement(badQureg, 0),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        SECTION( "invalid target qubit" ) {
 
            int badTarget = GENERATE_COPY( -1, qureg.numQubits );
            REQUIRE_THROWS_WITH(
                applyQubitMeasurement(qureg, badTarget),
                ContainsSubstring("target")
            );
        }
    }
}

TEST_CASE() [16/19]

TEST_CASE	(	"applyQubitMeasurementAndGetProb"	,
		TEST_CATEGORY_OPS	)

Definition at line 2175 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); }
    }
 
    SECTION( LABEL_VALIDATION ) {
        
        Qureg qureg = getArbitraryCachedStatevec();
        qreal outProb = 0;
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            REQUIRE_THROWS_WITH(
                applyQubitMeasurementAndGetProb(badQureg, 0, &outProb),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        SECTION( "invalid target qubit" ) {
 
            int badTarget = GENERATE_COPY( -1, qureg.numQubits );
            REQUIRE_THROWS_WITH(
                applyQubitMeasurementAndGetProb(qureg, badTarget, &outProb),
                ContainsSubstring("target")
            );
        }
    }
}

TEST_CASE() [17/19]

TEST_CASE	(	"applyQubitProjector"	,
		TEST_CATEGORY_OPS	)

Definition at line 1532 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); }
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        Qureg qureg = getArbitraryCachedStatevec();
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            REQUIRE_THROWS_WITH(
                applyQubitProjector(badQureg, 0, 0),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        SECTION( "invalid target qubit" ) {
 
            int badTarget = GENERATE_COPY( -1, qureg.numQubits );
            REQUIRE_THROWS_WITH(
                applyQubitProjector(qureg, badTarget, 0),
                ContainsSubstring("target")
            );
        }
 
        SECTION( "invalid outcome" ) {
 
            int badOutcome = GENERATE_COPY( -1, 2 );
            REQUIRE_THROWS_WITH(
                applyQubitProjector(qureg, 0, badOutcome),
                ContainsSubstring("outcome")
            );
        }
 
        // projector does NOT validate outcome probability
    }
}

TEST_CASE() [18/19]

TEST_CASE	(	"applyTwoQubitPhaseFlip"	,
		TEST_CATEGORY_OPS	)

Definition at line 1343 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 1345 of file operations.cpp.

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