Initialisation

	TEST_CASE ("initBlankState", TEST_CATEGORY)
	TEST_CASE ("initZeroState", TEST_CATEGORY)
	TEST_CASE ("initPlusState", TEST_CATEGORY)
	TEST_CASE ("initClassicalState", TEST_CATEGORY)
	TEST_CASE ("initDebugState", TEST_CATEGORY)
	TEST_CASE ("initRandomPureState", TEST_CATEGORY)
	TEST_CASE ("initRandomMixedState", TEST_CATEGORY)
	TEST_CASE ("initArbitraryPureState", TEST_CATEGORY)
	TEST_CASE ("setQuregAmps", TEST_CATEGORY)
	TEST_CASE ("setDensityQuregFlatAmps", TEST_CATEGORY)
	TEST_CASE ("setDensityQuregAmps", TEST_CATEGORY)
	TEST_CASE ("setQuregToRenormalized", TEST_CATEGORY)
	TEST_CASE ("setQuregToPauliStrSum", TEST_CATEGORY)

Detailed Description

Function Documentation

TEST_CASE() [1/13]

TEST_CASE	(	"initArbitraryPureState"	,
		TEST_CATEGORY	)

Definition at line 224 of file initialisations.cpp.

                                                     {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        // works for unnormalised states
        qvector refVec = getRandomVector(getPow2(getNumCachedQubits()));
        qmatrix refMat = getOuterProduct(refVec, refVec);
 
        auto apiFunc = [&](Qureg qureg) { initArbitraryPureState(qureg, refVec.data()); };
 
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(getCachedStatevecs(), apiFunc, refVec); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(getCachedDensmatrs(), apiFunc, refMat); }
    }
 
    /// @todo input validation
}

TEST_CASE() [2/13]

TEST_CASE	(	"initBlankState"	,
		TEST_CATEGORY	)

TESTS

Definition at line 72 of file initialisations.cpp.

                                             {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(getCachedStatevecs(), initBlankState, getRefStatevec()); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(getCachedDensmatrs(), initBlankState, getRefDensmatr()); }
    }
 
    /// @todo input validation
}

TEST_CASE() [3/13]

TEST_CASE	(	"initClassicalState"	,
		TEST_CATEGORY	)

Definition at line 118 of file initialisations.cpp.

                                                 {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numQubits = getNumCachedQubits();
        int numInds = (int) getPow2(numQubits);
        int stateInd = GENERATE_COPY( range(0,numInds) );
 
        qvector refVec = getRefStatevec(); refVec[stateInd]           = 1; // |i> = {0, ..., 1, 0, ...}
        qmatrix refMat = getRefDensmatr(); refMat[stateInd][stateInd] = 1; // |i><i| 
 
        auto apiFunc = [&](Qureg qureg) { initClassicalState(qureg, stateInd); };
 
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(getCachedStatevecs(), apiFunc, refVec); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(getCachedDensmatrs(), apiFunc, refMat); }
    }
 
    /// @todo input validation
}

TEST_CASE() [4/13]

TEST_CASE	(	"initDebugState"	,
		TEST_CATEGORY	)

Definition at line 139 of file initialisations.cpp.

                                             {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        qvector refVec = getRefStatevec(); setToDebugState(refVec); // |debug>
        qmatrix refMat = getRefDensmatr(); setToDebugState(refMat); // ||debug>>
 
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(getCachedStatevecs(), initDebugState, refVec); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(getCachedDensmatrs(), initDebugState, refMat); }
    }
 
    /// @todo input validation
}

TEST_CASE() [5/13]

TEST_CASE	(	"initPlusState"	,
		TEST_CATEGORY	)

Definition at line 99 of file initialisations.cpp.

                                            {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numQubits = getNumCachedQubits();
        qreal vecElem = 1. / std::sqrt(getPow2(numQubits));
        qreal matElem = 1. / getPow2(numQubits);
 
        qvector refVec = getConstantVector(getPow2(numQubits), vecElem); // |+> = 1/sqrt(2^N) {1, ...}
        qmatrix refMat = getConstantMatrix(getPow2(numQubits), matElem); // |+><+| = 1/2^N {{1, ...}, ...}
 
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(getCachedStatevecs(), initPlusState, refVec); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(getCachedDensmatrs(), initPlusState, refMat); }
    }
 
    /// @todo input validation
}

TEST_CASE() [6/13]

TEST_CASE	(	"initRandomMixedState"	,
		TEST_CATEGORY	)

Definition at line 187 of file initialisations.cpp.

                                                   {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        // this test does not use reference states
 
        GENERATE( range(0,10) );
        int numPureStates = GENERATE( 1, 2, 10 );
 
        auto testFunc = [&](Qureg qureg) {
 
            initRandomMixedState(qureg, numPureStates);
            
            /// @todo
            /// these not-all-same-amp checks can be made much more rigorous,
            /// by e.g. asserting distinct nodes haven't generated all the same
            /// amplitudes (we currently observe this by eye)
            syncQuregFromGpu(qureg);
            REQUIRE( qureg.cpuAmps[0] != qureg.cpuAmps[1] ); // performed on all nodes
 
            qreal prob = calcTotalProb(qureg);
            REQUIRE_AGREE( prob, 1 );
 
            qreal purity = calcPurity(qureg);
            if (numPureStates == 1)
                REQUIRE_AGREE( purity, 1 );
            else
                REQUIRE( purity < 1 );
        };
 
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(getCachedDensmatrs(), testFunc); }
    }
 
    /// @todo input validation
}

TEST_CASE() [7/13]

TEST_CASE	(	"initRandomPureState"	,
		TEST_CATEGORY	)

Definition at line 154 of file initialisations.cpp.

                                                  {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        // this test does not use reference states
        GENERATE( range(0,10) );
 
        auto testFunc = [&](Qureg qureg) {
 
            initRandomPureState(qureg);
            
            /// @todo
            /// these not-all-same-amp checks can be made much more rigorous,
            /// by e.g. asserting distinct nodes haven't generated all the same
            /// amplitudes (we currently observe this by eye)
            syncQuregFromGpu(qureg);
            REQUIRE( qureg.cpuAmps[0] != qureg.cpuAmps[1] );
 
            qreal prob = calcTotalProb(qureg);
            REQUIRE_AGREE( prob, 1 );
 
            qreal purity = calcPurity(qureg);
            REQUIRE_AGREE( purity, 1 );
        };
 
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(getCachedStatevecs(), testFunc); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(getCachedDensmatrs(), testFunc); }
    }
 
    /// @todo input validation
}

TEST_CASE() [8/13]

TEST_CASE	(	"initZeroState"	,
		TEST_CATEGORY	)

Definition at line 84 of file initialisations.cpp.

                                            {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        qvector refVec = getRefStatevec(); refVec[0]    = 1; // |0> = {1, 0...}
        qmatrix refMat = getRefDensmatr(); refMat[0][0] = 1; // |0><0| = {{1,0...},{0...}...}
 
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(getCachedStatevecs(), initZeroState, refVec); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(getCachedDensmatrs(), initZeroState, refMat); }
    }
 
    /// @todo input validation
}

TEST_CASE() [9/13]

TEST_CASE	(	"setDensityQuregAmps"	,
		TEST_CATEGORY	)

Definition at line 313 of file initialisations.cpp.

                                                  {
 
    //void setDensityQuregAmps(Qureg qureg, qindex startRow, qindex startCol, qcomp** amps, qindex numRows, qindex numCols);
 
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numTotalRowsCols = getPow2(getNumCachedQubits());
 
        // systematic iteration is WAY too slow
        GENERATE( range(0,1000) );
        int numSetRows = getRandomInt(1, numTotalRowsCols+1);
        int numSetCols = getRandomInt(1, numTotalRowsCols+1);
        int startRow = getRandomInt(0, numTotalRowsCols - numSetRows);
        int startCol = getRandomInt(0, numTotalRowsCols - numSetCols);
 
        // caution that amps is 'qmatrix' despite not being square
        qmatrix amps = getRandomNonSquareMatrix(numSetRows, numSetCols);
 
        auto testFunc = [&](Qureg qureg) {
 
            // initialise qureg randomly
            qmatrix refMat = getRandomMatrix(numTotalRowsCols);
            setQuregToReference(qureg, refMat);
 
            // API needs nested pointers
            std::vector<qcomp*> rowPtrs(numSetRows);
            for (size_t r=0; r<numSetRows; r++)
                rowPtrs[r] = amps[r].data();
 
            // overwrite a sub-matrix of refMat and Qureg
            setSubMatrix(refMat, amps, startRow, startCol);
            setDensityQuregAmps(qureg, startRow, startCol, rowPtrs.data(), numSetRows, numSetCols);
 
            // check that both targeted and non-targeted amps agree
            REQUIRE_AGREE( qureg, refMat );
        };
 
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(getCachedDensmatrs(), testFunc); }
    
    }
 
    /// @todo input validation
}

TEST_CASE() [10/13]

TEST_CASE	(	"setDensityQuregFlatAmps"	,
		TEST_CATEGORY	)

Definition at line 275 of file initialisations.cpp.

                                                      {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numTotalRows = getPow2(getNumCachedQubits());
        int numTotalAmps = numTotalRows * numTotalRows;
 
        // systematic iteration is WAY too slow
        GENERATE( range(0,1000) );
        int numSetAmps = getRandomInt(0, numTotalAmps + 1);
        int startInd = getRandomInt(0, numTotalAmps - numSetAmps);
        qvector amps = getRandomVector(numSetAmps);
 
        auto testFunc = [&](Qureg qureg) {
 
            // initialise qureg randomly
            qmatrix refMat = getRandomMatrix(numTotalRows);
            setQuregToReference(qureg, refMat);
 
            // overwrite a contiguous region of row-major refMat, column-wise
            refMat = getTranspose(refMat);
            setSubMatrix(refMat, amps, startInd);
            refMat = getTranspose(refMat);
 
            // modify the same contiguous region of column-major qureg
            setDensityQuregFlatAmps(qureg, startInd, amps.data(), numSetAmps);
        
            // check that both targeted and non-targeted amps agree
            REQUIRE_AGREE( qureg, refMat );
        };
 
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(getCachedDensmatrs(), testFunc); }
    }
 
    /// @todo input validation
}

TEST_CASE() [11/13]

TEST_CASE	(	"setQuregAmps"	,
		TEST_CATEGORY	)

Definition at line 244 of file initialisations.cpp.

                                           {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numTotalAmps = getPow2(getNumCachedQubits());
        int numSetAmps = GENERATE_COPY( range(0,numTotalAmps+1) ); 
        int startInd = GENERATE_COPY( range(0,numTotalAmps-numSetAmps) );
        qvector amps = getRandomVector(numSetAmps);
 
        auto testFunc = [&](Qureg qureg) {
 
            // initialise qureg randomly
            qvector refVec = getRandomVector(numTotalAmps);
            setQuregToReference(qureg, refVec);
 
            // modify only subset of refVec amps and qureg...
            setSubVector(refVec, amps, startInd);
            setQuregAmps(qureg, startInd, amps.data(), numSetAmps);
        
            // so that we simultaneously check targeted amps 
            // are modified while non-targeted are not
            REQUIRE_AGREE( qureg, refVec );
        };
 
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(getCachedStatevecs(), testFunc); }
    }
 
    /// @todo input validation
}

TEST_CASE() [12/13]

TEST_CASE	(	"setQuregToPauliStrSum"	,
		TEST_CATEGORY	)

Definition at line 390 of file initialisations.cpp.

                                                    {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        GENERATE( range(0,10) );
        int numQubits = getNumCachedQubits();
        int numTerms = GENERATE_COPY( 1, numQubits, getPow2(2*numQubits) );
        PauliStrSum sum = createRandomPauliStrSum(numQubits, numTerms);
        qmatrix refMat = getMatrix(sum, numQubits);
 
        auto apiFunc = [&](Qureg qureg) { setQuregToPauliStrSum(qureg, sum); };
 
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(getCachedDensmatrs(), apiFunc, refMat); }
    }
 
    /// @todo input validation
}

TEST_CASE() [13/13]

TEST_CASE	(	"setQuregToRenormalized"	,
		TEST_CATEGORY	)

Definition at line 359 of file initialisations.cpp.

                                                     {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        GENERATE( range(0,10) );
        qindex dim = getPow2(getNumCachedQubits());
        qvector refVec = getRandomVector(dim);
        qmatrix refMat = getRandomMatrix(dim);
 
        // eliminate random chance of tr(refMat)=0, triggering validation
        if (doScalarsAgree(getTrace(refMat), 0))
            refMat[0][0] += 1/(qreal) dim;
 
        // [=] stores current (pre-normalised) reference objects
        auto funcVec = [=](Qureg qureg) { setQuregToReference(qureg, refVec); setQuregToRenormalized(qureg); };
        auto funcMat = [=](Qureg qureg) { setQuregToReference(qureg, refMat); setQuregToRenormalized(qureg); };
 
        // setQuregToRenormalized() makes statevectors become valid
        refVec = getNormalised(refVec);
 
        // but it only divides density matrices by the sum of the real-elems of their diagonals
        refMat /= getReferenceProbability(refMat);
 
        SECTION( LABEL_STATEVEC ) { TEST_ON_CACHED_QUREGS(getCachedStatevecs(), funcVec, refVec); }
        SECTION( LABEL_DENSMATR ) { TEST_ON_CACHED_QUREGS(getCachedDensmatrs(), funcMat, refMat); }
    }
 
    /// @todo input validation
}