Multiplication

	TEST_CASE ("leftapplySwap", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyPauliX", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyPauliY", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyPauliZ", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyPauliStr", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyPauliGadget", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyCompMatr1", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyCompMatr2", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyDiagMatr1", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyDiagMatr2", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplySwap", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyPauliX", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyPauliY", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyPauliZ", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyPauliStr", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyPauliGadget", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyCompMatr1", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyCompMatr2", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyDiagMatr1", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyDiagMatr2", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyCompMatr", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyDiagMatr", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyDiagMatrPower", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyMultiQubitNot", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyPhaseGadget", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyCompMatr", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyDiagMatr", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyDiagMatrPower", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyMultiQubitNot", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyPhaseGadget", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyFullStateDiagMatr", TEST_CATEGORY_MULT LABEL_MIXED_DEPLOY_TAG)
	TEST_CASE ("rightapplyFullStateDiagMatr", TEST_CATEGORY_MULT LABEL_MIXED_DEPLOY_TAG)
	TEST_CASE ("leftapplyFullStateDiagMatrPower", TEST_CATEGORY_MULT LABEL_MIXED_DEPLOY_TAG)
	TEST_CASE ("rightapplyFullStateDiagMatrPower", TEST_CATEGORY_MULT LABEL_MIXED_DEPLOY_TAG)
	TEST_CASE ("leftapplyQubitProjector", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyQubitProjector", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyMultiQubitProjector", TEST_CATEGORY_MULT)
	TEST_CASE ("rightapplyMultiQubitProjector", TEST_CATEGORY_MULT)
	TEST_CASE ("leftapplyPauliStrSum", TEST_CATEGORY_MULT LABEL_MIXED_DEPLOY_TAG)
	TEST_CASE ("rightapplyPauliStrSum", TEST_CATEGORY_MULT LABEL_MIXED_DEPLOY_TAG)

Detailed Description

Function Documentation

TEST_CASE() [1/40]

TEST_CASE	(	"leftapplyCompMatr"	,
		TEST_CATEGORY_MULT	)

Definition at line 2410 of file operations.cpp.

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

TEST_CASE() [2/40]

TEST_CASE	(	"leftapplyCompMatr1"	,
		TEST_CATEGORY_MULT	)

Definition at line 2386 of file operations.cpp.

{ testOperation<zero,one,compmatr,leftapply>(leftapplyCompMatr1,   nullptr); }

TEST_CASE() [3/40]

TEST_CASE	(	"leftapplyCompMatr2"	,
		TEST_CATEGORY_MULT	)

Definition at line 2387 of file operations.cpp.

{ testOperation<zero,two,compmatr,leftapply>(leftapplyCompMatr2,   nullptr); }

TEST_CASE() [4/40]

TEST_CASE	(	"leftapplyDiagMatr"	,
		TEST_CATEGORY_MULT	)

Definition at line 2415 of file operations.cpp.

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

TEST_CASE() [5/40]

TEST_CASE	(	"leftapplyDiagMatr1"	,
		TEST_CATEGORY_MULT	)

Definition at line 2388 of file operations.cpp.

{ testOperation<zero,one,diagmatr,leftapply>(leftapplyDiagMatr1,   nullptr); }

TEST_CASE() [6/40]

TEST_CASE	(	"leftapplyDiagMatr2"	,
		TEST_CATEGORY_MULT	)

Definition at line 2389 of file operations.cpp.

{ testOperation<zero,two,diagmatr,leftapply>(leftapplyDiagMatr2,   nullptr); }

TEST_CASE() [7/40]

TEST_CASE	(	"leftapplyDiagMatrPower"	,
		TEST_CATEGORY_MULT	)

Definition at line 2420 of file operations.cpp.

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

TEST_CASE() [8/40]

TEST_CASE	(	"leftapplyFullStateDiagMatr"	,
		TEST_CATEGORY_MULT	LABEL_MIXED_DEPLOY_TAG )

Definition at line 2467 of file operations.cpp.

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

TEST_CASE() [9/40]

TEST_CASE	(	"leftapplyFullStateDiagMatrPower"	,
		TEST_CATEGORY_MULT	LABEL_MIXED_DEPLOY_TAG )

Definition at line 2524 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 leftapplyFullStateDiagMatrPower(qureg, matr, exponent);
        };
 
        CAPTURE( exponent );
        
        GENERATE( range(0, getNumTestedMixedDeploymentRepetitions()) );
 
        SECTION( LABEL_STATEVEC ) {
 
            auto refFunc = [&] (qvector& state, qmatrix matr) { 
                matr = getPowerOfDiagonalMatrix(matr, exponent);
                leftapplyReferenceOperator(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);
                leftapplyReferenceOperator(state, matr);
            };
 
            TEST_ON_CACHED_QUREG_AND_MATRIX( cachedDM, cachedMatrs, apiFunc, refDM, refMatr, refFunc);
        }
    }
 
    /// @todo input validation
}

TEST_CASE() [10/40]

TEST_CASE	(	"leftapplyMultiQubitNot"	,
		TEST_CATEGORY_MULT	)

Definition at line 2425 of file operations.cpp.

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

TEST_CASE() [11/40]

TEST_CASE	(	"leftapplyMultiQubitProjector"	,
		TEST_CATEGORY_MULT	)

Definition at line 2728 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) {
            leftapplyMultiQubitProjector(qureg, targets.data(), outcomes.data(), numTargs);
            leftapplyReferenceOperator(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(
                leftapplyMultiQubitProjector(badQureg, targets, outcomes, numTargets),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        SECTION( "invalid target qubits" ) {
 
            int badTargets[] = {0, 1, GENERATE_COPY( -1, qureg.numQubits) };
            REQUIRE_THROWS_WITH(
                leftapplyMultiQubitProjector(qureg, badTargets, outcomes, numTargets),
                ContainsSubstring("target")
            );
        }
 
        SECTION( "duplicate target qubits" ) {
 
            int dupTargets[] = {0, 1, 1};
            REQUIRE_THROWS_WITH(
                leftapplyMultiQubitProjector(qureg, dupTargets, outcomes, numTargets),
                ContainsSubstring("duplicate")
            );
        }
 
        SECTION( "invalid number of targets" ) {
            
            int badNumTargs = GENERATE( 0, -1 );
            REQUIRE_THROWS_WITH(
                leftapplyMultiQubitProjector(qureg, targets, outcomes, badNumTargs),
                ContainsSubstring("targets")
            );
 
            badNumTargs = qureg.numQubits + 1;
            REQUIRE_THROWS_WITH(
                leftapplyMultiQubitProjector(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(
                leftapplyMultiQubitProjector(qureg, targets, badOutcomes, numTargets),
                ContainsSubstring("outcome")
            );
        }
 
        SECTION( "targets mismatch outcomes (C++ only)" ) {
 
            REQUIRE_THROWS_WITH(
                leftapplyMultiQubitProjector(qureg, {0,1,2}, {0,1}),
                ContainsSubstring("inconsistent")
            );
        }
 
        // projector does NOT validate outcome probability
    }
}

TEST_CASE() [12/40]

TEST_CASE	(	"leftapplyPauliGadget"	,
		TEST_CATEGORY_MULT	)

Definition at line 2385 of file operations.cpp.

{ testOperation<zero,any,pauligad,leftapply>(leftapplyPauliGadget, nullptr); }

TEST_CASE() [13/40]

TEST_CASE	(	"leftapplyPauliStr"	,
		TEST_CATEGORY_MULT	)

Definition at line 2384 of file operations.cpp.

{ testOperation<zero,any,paulistr,leftapply>(leftapplyPauliStr,    nullptr); }

TEST_CASE() [14/40]

TEST_CASE	(	"leftapplyPauliStrSum"	,
		TEST_CATEGORY_MULT	LABEL_MIXED_DEPLOY_TAG )

Definition at line 2924 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);
            leftapplyPauliStrSum(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); }
    }
 
    SECTION( LABEL_VALIDATION ) {
       
        Qureg qureg = getArbitraryCachedStatevec();
        PauliStrSum sum = createRandomPauliStrSum(numQubits, 2);
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            Qureg workspace = createCloneQureg(qureg);
            REQUIRE_THROWS_WITH(
                leftapplyPauliStrSum(badQureg, sum, workspace),
                ContainsSubstring("invalid Qureg")
            );
            destroyQureg(workspace);
        }
 
        destroyPauliStrSum(sum);
 
        /// @todo remaining input validation
    }
}

TEST_CASE() [15/40]

TEST_CASE	(	"leftapplyPauliX"	,
		TEST_CATEGORY_MULT	)

Definition at line 2381 of file operations.cpp.

{ testOperation<zero,one,none,leftapply>(leftapplyPauliX, FixedMatrices::X); }

TEST_CASE() [16/40]

TEST_CASE	(	"leftapplyPauliY"	,
		TEST_CATEGORY_MULT	)

Definition at line 2382 of file operations.cpp.

{ testOperation<zero,one,none,leftapply>(leftapplyPauliY, FixedMatrices::Y); }

TEST_CASE() [17/40]

TEST_CASE	(	"leftapplyPauliZ"	,
		TEST_CATEGORY_MULT	)

Definition at line 2383 of file operations.cpp.

{ testOperation<zero,one,none,leftapply>(leftapplyPauliZ, FixedMatrices::Z); }

TEST_CASE() [18/40]

TEST_CASE	(	"leftapplyPhaseGadget"	,
		TEST_CATEGORY_MULT	)

Definition at line 2430 of file operations.cpp.

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

TEST_CASE() [19/40]

TEST_CASE	(	"leftapplyQubitProjector"	,
		TEST_CATEGORY_MULT	)

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

TEST_CASE() [20/40]

TEST_CASE	(	"leftapplySwap"	,
		TEST_CATEGORY_MULT	)

OPERATOR TESTS

Definition at line 2380 of file operations.cpp.

{ testOperation<zero,two,none,leftapply>(leftapplySwap, FixedMatrices::SWAP); }

TEST_CASE() [21/40]

TEST_CASE	(	"rightapplyCompMatr"	,
		TEST_CATEGORY_MULT	)

Definition at line 2436 of file operations.cpp.

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

TEST_CASE() [22/40]

TEST_CASE	(	"rightapplyCompMatr1"	,
		TEST_CATEGORY_MULT	)

Definition at line 2397 of file operations.cpp.

{ testOperation<zero,one,compmatr,rightapply>(rightapplyCompMatr1,   nullptr); }

TEST_CASE() [23/40]

TEST_CASE	(	"rightapplyCompMatr2"	,
		TEST_CATEGORY_MULT	)

Definition at line 2398 of file operations.cpp.

{ testOperation<zero,two,compmatr,rightapply>(rightapplyCompMatr2,   nullptr); }

TEST_CASE() [24/40]

TEST_CASE	(	"rightapplyDiagMatr"	,
		TEST_CATEGORY_MULT	)

Definition at line 2441 of file operations.cpp.

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

TEST_CASE() [25/40]

TEST_CASE	(	"rightapplyDiagMatr1"	,
		TEST_CATEGORY_MULT	)

Definition at line 2399 of file operations.cpp.

{ testOperation<zero,one,diagmatr,rightapply>(rightapplyDiagMatr1,   nullptr); }

TEST_CASE() [26/40]

TEST_CASE	(	"rightapplyDiagMatr2"	,
		TEST_CATEGORY_MULT	)

Definition at line 2400 of file operations.cpp.

{ testOperation<zero,two,diagmatr,rightapply>(rightapplyDiagMatr2,   nullptr); }

TEST_CASE() [27/40]

TEST_CASE	(	"rightapplyDiagMatrPower"	,
		TEST_CATEGORY_MULT	)

Definition at line 2446 of file operations.cpp.

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

TEST_CASE() [28/40]

TEST_CASE	(	"rightapplyFullStateDiagMatr"	,
		TEST_CATEGORY_MULT	LABEL_MIXED_DEPLOY_TAG )

Definition at line 2499 of file operations.cpp.

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

TEST_CASE() [29/40]

TEST_CASE	(	"rightapplyFullStateDiagMatrPower"	,
		TEST_CATEGORY_MULT	LABEL_MIXED_DEPLOY_TAG )

Definition at line 2568 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 rightapplyFullStateDiagMatrPower(qureg, matr, exponent);
        };
 
        CAPTURE( exponent );
        
        GENERATE( range(0, getNumTestedMixedDeploymentRepetitions()) );
 
        SECTION( LABEL_DENSMATR ) {
 
            auto refFunc = [&] (qmatrix& state, qmatrix matr) { 
                matr = getPowerOfDiagonalMatrix(matr, exponent);
                rightapplyReferenceOperator(state, matr);
            };
 
            TEST_ON_CACHED_QUREG_AND_MATRIX( cachedDM, cachedMatrs, apiFunc, refDM, refMatr, refFunc);
        }
    }
 
    /// @todo input validation
}

TEST_CASE() [30/40]

TEST_CASE	(	"rightapplyMultiQubitNot"	,
		TEST_CATEGORY_MULT	)

Definition at line 2451 of file operations.cpp.

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

TEST_CASE() [31/40]

TEST_CASE	(	"rightapplyMultiQubitProjector"	,
		TEST_CATEGORY_MULT	)

Definition at line 2822 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) {
            rightapplyMultiQubitProjector(qureg, targets.data(), outcomes.data(), numTargs);
            rightapplyReferenceOperator(ref, projector);
        };
 
        CAPTURE( targets, outcomes );
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc); }
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        Qureg qureg = getArbitraryCachedDensmatr();
        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(
                rightapplyMultiQubitProjector(badQureg, targets, outcomes, numTargets),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        SECTION( "qureg is not density matrix" ) {
 
            Qureg badQureg = getArbitraryCachedStatevec();
            REQUIRE_THROWS_WITH(
                rightapplyMultiQubitProjector(badQureg, targets, outcomes, numTargets),
                ContainsSubstring("received a statevector")
            );
        }
 
        SECTION( "invalid target qubits" ) {
 
            int badTargets[] = {0, 1, GENERATE_COPY( -1, qureg.numQubits) };
            REQUIRE_THROWS_WITH(
                rightapplyMultiQubitProjector(qureg, badTargets, outcomes, numTargets),
                ContainsSubstring("target")
            );
        }
 
        SECTION( "duplicate target qubits" ) {
 
            int dupTargets[] = {0, 1, 1};
            REQUIRE_THROWS_WITH(
                rightapplyMultiQubitProjector(qureg, dupTargets, outcomes, numTargets),
                ContainsSubstring("duplicate")
            );
        }
 
        SECTION( "invalid number of targets" ) {
            
            int badNumTargs = GENERATE( 0, -1 );
            REQUIRE_THROWS_WITH(
                rightapplyMultiQubitProjector(qureg, targets, outcomes, badNumTargs),
                ContainsSubstring("targets")
            );
 
            badNumTargs = qureg.numQubits + 1;
            REQUIRE_THROWS_WITH(
                rightapplyMultiQubitProjector(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(
                rightapplyMultiQubitProjector(qureg, targets, badOutcomes, numTargets),
                ContainsSubstring("outcome")
            );
        }
 
        SECTION( "targets mismatch outcomes (C++ only)" ) {
 
            REQUIRE_THROWS_WITH(
                rightapplyMultiQubitProjector(qureg, {0,1,2}, {0,1}),
                ContainsSubstring("inconsistent")
            );
        }
 
        // projector does NOT validate outcome probability
    }
}

TEST_CASE() [32/40]

TEST_CASE	(	"rightapplyPauliGadget"	,
		TEST_CATEGORY_MULT	)

Definition at line 2396 of file operations.cpp.

{ testOperation<zero,any,pauligad,rightapply>(rightapplyPauliGadget, nullptr); }

TEST_CASE() [33/40]

TEST_CASE	(	"rightapplyPauliStr"	,
		TEST_CATEGORY_MULT	)

Definition at line 2395 of file operations.cpp.

{ testOperation<zero,any,paulistr,rightapply>(rightapplyPauliStr,    nullptr); }

TEST_CASE() [34/40]

TEST_CASE	(	"rightapplyPauliStrSum"	,
		TEST_CATEGORY_MULT	LABEL_MIXED_DEPLOY_TAG )

Definition at line 2974 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);
            rightapplyPauliStrSum(qureg, sum, workspace);
            destroyQureg(workspace);
 
            ref = ref * getMatrix(sum, numQubits);
        };
 
        CAPTURE( numTerms );
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc); }
    }
 
    SECTION( LABEL_VALIDATION ) {
        
        Qureg qureg = getArbitraryCachedStatevec();
        PauliStrSum sum = createRandomPauliStrSum(numQubits, 2);
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            Qureg workspace = createCloneQureg(qureg);
            REQUIRE_THROWS_WITH(
                rightapplyPauliStrSum(badQureg, sum, workspace),
                ContainsSubstring("invalid Qureg")
            );
            destroyQureg(workspace);
        }
 
        destroyPauliStrSum(sum);
 
        /// @todo remaining input validation
    }
}

TEST_CASE() [35/40]

TEST_CASE	(	"rightapplyPauliX"	,
		TEST_CATEGORY_MULT	)

Definition at line 2392 of file operations.cpp.

{ testOperation<zero,one,none,rightapply>(rightapplyPauliX, FixedMatrices::X); }

TEST_CASE() [36/40]

TEST_CASE	(	"rightapplyPauliY"	,
		TEST_CATEGORY_MULT	)

Definition at line 2393 of file operations.cpp.

{ testOperation<zero,one,none,rightapply>(rightapplyPauliY, FixedMatrices::Y); }

TEST_CASE() [37/40]

TEST_CASE	(	"rightapplyPauliZ"	,
		TEST_CATEGORY_MULT	)

Definition at line 2394 of file operations.cpp.

{ testOperation<zero,one,none,rightapply>(rightapplyPauliZ, FixedMatrices::Z); }

TEST_CASE() [38/40]

TEST_CASE	(	"rightapplyPhaseGadget"	,
		TEST_CATEGORY_MULT	)

Definition at line 2456 of file operations.cpp.

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

TEST_CASE() [39/40]

TEST_CASE	(	"rightapplyQubitProjector"	,
		TEST_CATEGORY_MULT	)

Definition at line 2661 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) {
            rightapplyQubitProjector(qureg, target, outcome);
            rightapplyReferenceOperator(ref, {target}, projector);
        };
 
        CAPTURE( target, outcome );
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(densmatrQuregs, densmatrRef, testFunc); }
    }
 
    SECTION( LABEL_VALIDATION ) {
        
        Qureg qureg = getArbitraryCachedDensmatr();
 
        SECTION( "qureg uninitialised" ) {
 
            Qureg badQureg = qureg;
            badQureg.numQubits = -1;
            REQUIRE_THROWS_WITH(
                rightapplyQubitProjector(badQureg, 0, 0),
                ContainsSubstring("invalid Qureg")
            );
        }
 
        SECTION( "qureg is not density matrix" ) {
 
            Qureg badQureg = getArbitraryCachedStatevec();
            REQUIRE_THROWS_WITH(
                rightapplyQubitProjector(badQureg, 0, 0),
                ContainsSubstring("received a statevector")
            );
        }
 
        SECTION( "invalid target qubit" ) {
            
            int badTarget = GENERATE_COPY( -1, qureg.numQubits );
            REQUIRE_THROWS_WITH(
                rightapplyQubitProjector(qureg, badTarget, 0),
                ContainsSubstring("target")
            );
        }
 
        SECTION( "invalid outcome" ) {
 
            int badOutcome = GENERATE_COPY( -1, 2 );
            REQUIRE_THROWS_WITH(
                rightapplyQubitProjector(qureg, 0, badOutcome),
                ContainsSubstring("outcome")
            );
        }
 
        // projector does NOT validate outcome probability
    }
}

TEST_CASE() [40/40]

TEST_CASE	(	"rightapplySwap"	,
		TEST_CATEGORY_MULT	)

Definition at line 2391 of file operations.cpp.

{ testOperation<zero,two,none,rightapply>(rightapplySwap, FixedMatrices::SWAP); }