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_OPS)
	TEST_CASE ("rightapplyQubitProjector", TEST_CATEGORY_OPS)
	TEST_CASE ("leftapplyMultiQubitProjector", TEST_CATEGORY_OPS)
	TEST_CASE ("rightapplyMultiQubitProjector", TEST_CATEGORY_OPS)
	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 1903 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 1879 of file operations.cpp.

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

TEST_CASE() [3/40]

TEST_CASE	(	"leftapplyCompMatr2"	,
		TEST_CATEGORY_MULT	)

Definition at line 1880 of file operations.cpp.

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

TEST_CASE() [4/40]

TEST_CASE	(	"leftapplyDiagMatr"	,
		TEST_CATEGORY_MULT	)

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

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

TEST_CASE() [6/40]

TEST_CASE	(	"leftapplyDiagMatr2"	,
		TEST_CATEGORY_MULT	)

Definition at line 1882 of file operations.cpp.

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

TEST_CASE() [7/40]

TEST_CASE	(	"leftapplyDiagMatrPower"	,
		TEST_CATEGORY_MULT	)

Definition at line 1913 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 1960 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 2017 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 1918 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_OPS	)

Definition at line 2146 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); }
    }
 
    /// @todo input validation
}

TEST_CASE() [12/40]

TEST_CASE	(	"leftapplyPauliGadget"	,
		TEST_CATEGORY_MULT	)

Definition at line 1878 of file operations.cpp.

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

TEST_CASE() [13/40]

TEST_CASE	(	"leftapplyPauliStr"	,
		TEST_CATEGORY_MULT	)

Definition at line 1877 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 2197 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); }
    }
 
    /// @todo input validation
}

TEST_CASE() [15/40]

TEST_CASE	(	"leftapplyPauliX"	,
		TEST_CATEGORY_MULT	)

Definition at line 1874 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 1875 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 1876 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 1923 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_OPS	)

Definition at line 2095 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); }
    }
 
    /// @todo input validation
}

TEST_CASE() [20/40]

TEST_CASE	(	"leftapplySwap"	,
		TEST_CATEGORY_MULT	)

OPERATOR TESTS

Definition at line 1873 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 1929 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 1890 of file operations.cpp.

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

TEST_CASE() [23/40]

TEST_CASE	(	"rightapplyCompMatr2"	,
		TEST_CATEGORY_MULT	)

Definition at line 1891 of file operations.cpp.

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

TEST_CASE() [24/40]

TEST_CASE	(	"rightapplyDiagMatr"	,
		TEST_CATEGORY_MULT	)

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

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

TEST_CASE() [26/40]

TEST_CASE	(	"rightapplyDiagMatr2"	,
		TEST_CATEGORY_MULT	)

Definition at line 1893 of file operations.cpp.

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

TEST_CASE() [27/40]

TEST_CASE	(	"rightapplyDiagMatrPower"	,
		TEST_CATEGORY_MULT	)

Definition at line 1939 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 1992 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 2061 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 1944 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_OPS	)

Definition at line 2172 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); }
    }
 
    /// @todo input validation
}

TEST_CASE() [32/40]

TEST_CASE	(	"rightapplyPauliGadget"	,
		TEST_CATEGORY_MULT	)

Definition at line 1889 of file operations.cpp.

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

TEST_CASE() [33/40]

TEST_CASE	(	"rightapplyPauliStr"	,
		TEST_CATEGORY_MULT	)

Definition at line 1888 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 2227 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); }
    }
 
    /// @todo input validation
}

TEST_CASE() [35/40]

TEST_CASE	(	"rightapplyPauliX"	,
		TEST_CATEGORY_MULT	)

Definition at line 1885 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 1886 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 1887 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 1949 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_OPS	)

Definition at line 2121 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); }
    }
 
    /// @todo input validation
}

TEST_CASE() [40/40]

TEST_CASE	(	"rightapplySwap"	,
		TEST_CATEGORY_MULT	)

Definition at line 1884 of file operations.cpp.

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