Matrices

	TEST_CASE ("getCompMatr1", TEST_CATEGORY)
	TEST_CASE ("getCompMatr2", TEST_CATEGORY)
	TEST_CASE ("getDiagMatr1", TEST_CATEGORY)
	TEST_CASE ("getDiagMatr2", TEST_CATEGORY)
	TEST_CASE ("getInlineCompMatr1", TEST_CATEGORY)
	TEST_CASE ("getInlineCompMatr2", TEST_CATEGORY)
	TEST_CASE ("getInlineDiagMatr1", TEST_CATEGORY)
	TEST_CASE ("getInlineDiagMatr2", TEST_CATEGORY)
	TEST_CASE ("createCompMatr", TEST_CATEGORY)
	TEST_CASE ("createDiagMatr", TEST_CATEGORY)
	TEST_CASE ("createFullStateDiagMatr", TEST_CATEGORY)
	TEST_CASE ("createCustomFullStateDiagMatr", TEST_CATEGORY)
	TEST_CASE ("destroyCompMatr", TEST_CATEGORY)
	TEST_CASE ("destroyDiagMatr", TEST_CATEGORY)
	TEST_CASE ("destroyFullStateDiagMatr", TEST_CATEGORY)
	TEST_CASE ("syncCompMatr", TEST_CATEGORY)
	TEST_CASE ("syncDiagMatr", TEST_CATEGORY)
	TEST_CASE ("syncFullStateDiagMatr", TEST_CATEGORY)
	TEST_CASE ("setCompMatr", TEST_CATEGORY)
	TEST_CASE ("setDiagMatr", TEST_CATEGORY)
	TEST_CASE ("setInlineCompMatr", TEST_CATEGORY)
	TEST_CASE ("setInlineDiagMatr", TEST_CATEGORY)
	TEST_CASE ("createInlineCompMatr", TEST_CATEGORY)
	TEST_CASE ("createInlineDiagMatr", TEST_CATEGORY)

Detailed Description

Function Documentation

TEST_CASE() [1/24]

TEST_CASE	(	"createCompMatr"	,
		TEST_CATEGORY	)

Definition at line 394 of file matrices.cpp.

                                             {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        // inessential to link to cached Qureg sizes, but
        // provides a nice ballpark
        int maxNumQubits = getNumCachedQubits();
        int numQubits = GENERATE_COPY( range(1, maxNumQubits+1) );
        CAPTURE( numQubits );
 
        CompMatr matr = createCompMatr(numQubits);
        qmatrix blank = getZeroMatrix(getPow2(numQubits));
 
        // default elements
        REQUIRE_AGREE( matr, blank );
 
        // fields
        REQUIRE( matr.numQubits == numQubits );
        REQUIRE( matr.numRows == getPow2(numQubits) );
 
        // default properties
        REQUIRE( *(matr.isApproxUnitary)   == -1 ); // unknown
        REQUIRE( *(matr.isApproxHermitian) == -1 ); // unknown
        REQUIRE( *(matr.wasGpuSynced)      ==  0 ); // false
 
        // pointers
        REQUIRE( matr.cpuElems != nullptr );
        REQUIRE( matr.cpuElemsFlat != nullptr );
 
        if (getQuESTEnv().isGpuAccelerated)
            REQUIRE( matr.gpuElemsFlat != nullptr );
        else
            REQUIRE( matr.gpuElemsFlat == nullptr );
        
        destroyCompMatr(matr);
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "env not initialised" ) {
 
            // impossible to test
            SUCCEED( );
        }
 
        SECTION( "too few qubits" ) {
 
            int numQubits = GENERATE( -1, 0 );
 
            REQUIRE_THROWS_WITH( createCompMatr(numQubits), ContainsSubstring("must target one or more qubits") );
        }
 
        SECTION( "too many qubits" ) {
 
            // overflows qindex in all precisions
            REQUIRE_THROWS_WITH( createCompMatr(50), ContainsSubstring("maximum which can be addressed by the qindex type") );
 
            // overflows size_t in single precision (and ergo also in double and quad)
            REQUIRE_THROWS_WITH( createCompMatr(31), ContainsSubstring("necessary memory would overflow size_t") );
 
            // no overflows, but definitely exceeds local RAM and fails to allocate; frightens address sanitizer!
            // note the specific error message depends on the what backend the auto-deployer tried to use (e.g.
            // GPU-accel or distributed) and whether memory-probers realised there was insufficient memory in
            // advance or whether it proceeded to malloc() which subsequently failed
            #ifndef SANITIZER_IS_ACTIVE
            REQUIRE_THROWS_WITH( createCompMatr(25), 
                ContainsSubstring("failed") || 
                ContainsSubstring("insufficient available memory") || 
                ContainsSubstring("available GPU memory") ||
                ContainsSubstring("exceeds the available RAM") );
            #endif
        }
    }
}

TEST_CASE() [2/24]

TEST_CASE	(	"createCustomFullStateDiagMatr"	,
		TEST_CATEGORY	)

Definition at line 628 of file matrices.cpp.

                                                            {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        for (auto [label, mpi, gpu, omp] : getSupportedDeployments()) {
 
            DYNAMIC_SECTION( label ) {
 
                int minNumQubits = std::max({1, getLog2(getQuESTEnv().numNodes)});
                int maxNumQubits = std::min({20, minNumQubits + 1});
                int numQubits = GENERATE_COPY( range(minNumQubits, maxNumQubits+1) );
                CAPTURE( numQubits );
 
                FullStateDiagMatr matr = createCustomFullStateDiagMatr(numQubits, mpi, gpu, omp);
 
                // check state is blank
                bool isBlank = true;
                for (qindex i=0; i<matr.numElemsPerNode && isBlank; i++)
                    isBlank = (matr.cpuElems[i] == qcomp(0,0));
                REQUIRE( isBlank );
 
                // dimensions
                REQUIRE( matr.numQubits == numQubits );
                REQUIRE( matr.numElems == getPow2(numQubits) );
                REQUIRE( matr.numElemsPerNode == matr.numElems / (mpi? getQuESTEnv().numNodes : 1) );
 
                // accelerations
                REQUIRE( matr.isDistributed    == (int) (mpi && getQuESTEnv().numNodes > 1) );
                REQUIRE( matr.isGpuAccelerated == (int) gpu );
                REQUIRE( matr.isMultithreaded  == (int) omp );
 
                // default properties
                REQUIRE( *(matr.isApproxUnitary)       == -1 ); // unknown
                REQUIRE( *(matr.isApproxHermitian)     == -1 ); // unknown
                REQUIRE( *(matr.isApproxNonZero)       == -1 ); // unknown
                REQUIRE( *(matr.isStrictlyNonNegative) == -1 ); // unknown
                REQUIRE( *(matr.wasGpuSynced)          ==  0 ); // false
 
                // pointers
                REQUIRE( matr.cpuElems != nullptr );
 
                if (gpu) REQUIRE( matr.gpuElems != nullptr );
                else     REQUIRE( matr.gpuElems == nullptr );
                
                destroyFullStateDiagMatr(matr); 
            }
        }
 
    }
 
    SECTION( LABEL_VALIDATION ) {
    
        SECTION( "env not initialised" ) {
 
            // impossible to test
            SUCCEED( );
        }
 
        SECTION( "too few qubits" ) {
 
            int numQubits = GENERATE( -1, 0 );
 
            for (auto [label, mpi, gpu, omp] : getSupportedDeployments())
                REQUIRE_THROWS_WITH( createCustomFullStateDiagMatr(numQubits, mpi,gpu,omp), ContainsSubstring("must target one or more qubits") );
 
            if (getQuESTEnv().numNodes > 2) { // 1 node => min=1
                int minNumQubits = getLog2(getQuESTEnv().numNodes);
                REQUIRE_THROWS_WITH( createCustomFullStateDiagMatr(minNumQubits-1, 1,0,0), ContainsSubstring("node would contain fewer than one element") );
            }
        }
 
        SECTION( "too many qubits" ) {
 
            for (auto [label, mpi, gpu, omp] : getSupportedDeployments()) {
 
                // overflows qindex in all precisions
                REQUIRE_THROWS_WITH( createCustomFullStateDiagMatr(100, mpi,gpu,omp), ContainsSubstring("maximum which can be addressed by the qindex type") );
 
                // overflows size_t in single precision (and ergo also in double and quad)
                REQUIRE_THROWS_WITH( createCustomFullStateDiagMatr(62, mpi,gpu,omp), ContainsSubstring("memory would overflow size_t") );
 
                // no overflows, but definitely exceeds local RAM and fails to allocate; frightens address sanitizer!
                // note the specific error message depends on the what backend the auto-deployer tried to use (e.g.
                // GPU-accel or distributed) and whether memory-probers realised there was insufficient memory in
                // advance or whether it proceeded to malloc() which subsequently failed
                #ifndef SANITIZER_IS_ACTIVE
                REQUIRE_THROWS_WITH( createCustomFullStateDiagMatr(50, mpi,gpu,omp), 
                    ContainsSubstring("failed") || 
                    ContainsSubstring("insufficient available memory") || 
                    ContainsSubstring("available GPU memory") ||
                    ContainsSubstring("exceeds the available RAM") ||
                    ContainsSubstring("exceeds the local available RAM") );
                #endif
            }
        }
 
        SECTION( "unsupported deployments" ) {
 
            if (!getQuESTEnv().isDistributed)
                REQUIRE_THROWS_WITH( createCustomFullStateDiagMatr(1, 1,0,0), ContainsSubstring("non-distributed QuEST environment") );
 
            if (!getQuESTEnv().isGpuAccelerated)
                REQUIRE_THROWS_WITH( createCustomFullStateDiagMatr(1, 0,1,0), ContainsSubstring("non-GPU-accelerated QuEST environment") );
 
            if (!getQuESTEnv().isMultithreaded)
                REQUIRE_THROWS_WITH( createCustomFullStateDiagMatr(1, 0,0,1), ContainsSubstring("non-multithreaded QuEST environment") );
        }
    }
}

TEST_CASE() [3/24]

TEST_CASE	(	"createDiagMatr"	,
		TEST_CATEGORY	)

Definition at line 470 of file matrices.cpp.

                                             {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        // inessential to link to cached Qureg sizes, but
        // provides a nice ballpark
        int maxNumQubits = getNumCachedQubits();
        int numQubits = GENERATE_COPY( range(1, maxNumQubits+1) );
        CAPTURE( numQubits );
 
        DiagMatr matr = createDiagMatr(numQubits);
        qmatrix blank = getZeroMatrix(getPow2(numQubits));
 
        // default elements
        REQUIRE_AGREE( matr, blank );
 
        // fields
        REQUIRE( matr.numQubits == numQubits );
        REQUIRE( matr.numElems == getPow2(numQubits) );
 
        // default properties
        REQUIRE( *(matr.isApproxUnitary)       == -1 ); // unknown
        REQUIRE( *(matr.isApproxHermitian)     == -1 ); // unknown
        REQUIRE( *(matr.isApproxNonZero)       == -1 ); // unknown
        REQUIRE( *(matr.isStrictlyNonNegative) == -1 ); // unknown
        REQUIRE( *(matr.wasGpuSynced)          ==  0 ); // false
 
        // pointers
        REQUIRE( matr.cpuElems != nullptr );
 
        if (getQuESTEnv().isGpuAccelerated)
            REQUIRE( matr.gpuElems != nullptr );
        else
            REQUIRE( matr.gpuElems == nullptr );
        
        destroyDiagMatr(matr);
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "env not initialised" ) {
 
            // impossible to test
            SUCCEED( );
        }
 
        SECTION( "too few qubits" ) {
 
            int numQubits = GENERATE( -1, 0 );
 
            REQUIRE_THROWS_WITH( createDiagMatr(numQubits), ContainsSubstring("must target one or more qubits") );
        }
 
        SECTION( "too many qubits" ) {
 
            // overflows qindex in all precisions
            REQUIRE_THROWS_WITH( createDiagMatr(100), ContainsSubstring("maximum which can be addressed by the qindex type") );
 
            // overflows size_t in single precision (and ergo also in double and quad)
            REQUIRE_THROWS_WITH( createDiagMatr(62), ContainsSubstring("necessary memory would overflow size_t") );
 
            // no overflows, but definitely exceeds local RAM and fails to allocate; frightens address sanitizer!
            // note the specific error message depends on the what backend the auto-deployer tried to use (e.g.
            // GPU-accel or distributed) and whether memory-probers realised there was insufficient memory in
            // advance or whether it proceeded to malloc() which subsequently failed
            #ifndef SANITIZER_IS_ACTIVE
            REQUIRE_THROWS_WITH( createDiagMatr(50), 
                ContainsSubstring("failed") || 
                ContainsSubstring("insufficient available memory") || 
                ContainsSubstring("available GPU memory") ||
                ContainsSubstring("exceeds the available RAM") );
            #endif
        }
    }
}

TEST_CASE() [4/24]

TEST_CASE	(	"createFullStateDiagMatr"	,
		TEST_CATEGORY	)

Definition at line 547 of file matrices.cpp.

                                                      {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numQubits = GENERATE_COPY( range(1, 20) );
        CAPTURE( numQubits );
 
        // uses auto deployment
        FullStateDiagMatr matr = createFullStateDiagMatr(numQubits);
 
        // check state is blank
        bool isBlank = true;
        for (qindex i=0; i<matr.numElemsPerNode && isBlank; i++)
            isBlank = (matr.cpuElems[i] == qcomp(0,0));
        REQUIRE( isBlank );
 
        // dimensions
        REQUIRE( matr.numQubits == numQubits );
        REQUIRE( matr.numElems == getPow2(numQubits) );
        REQUIRE( matr.numElemsPerNode == matr.numElems / (matr.isDistributed? getQuESTEnv().numNodes : 1) );
 
        // default properties
        REQUIRE( *(matr.isApproxUnitary)       == -1 ); // unknown
        REQUIRE( *(matr.isApproxHermitian)     == -1 ); // unknown
        REQUIRE( *(matr.isApproxNonZero)       == -1 ); // unknown
        REQUIRE( *(matr.isStrictlyNonNegative) == -1 ); // unknown
        REQUIRE( *(matr.wasGpuSynced)          ==  0 ); // false
 
        // pointers
        REQUIRE( matr.cpuElems != nullptr );
 
        int gpu = matr.isGpuAccelerated;
        if (gpu) REQUIRE( matr.gpuElems != nullptr );
        else     REQUIRE( matr.gpuElems == nullptr );
        
        destroyFullStateDiagMatr(matr);
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "env not initialised" ) {
 
            // impossible to test
            SUCCEED( );
        }
 
        SECTION( "too few qubits" ) {
 
            int numQubits = GENERATE( -1, 0 );
 
            REQUIRE_THROWS_WITH( createFullStateDiagMatr(numQubits), ContainsSubstring("must target one or more qubits") );
        }
 
        SECTION( "too many qubits" ) {
 
            // overflows qindex in all precisions
            REQUIRE_THROWS_WITH( createFullStateDiagMatr(100), ContainsSubstring("maximum which can be addressed by the qindex type") );
 
            // overflows size_t in single precision (and ergo also in double and quad)
            REQUIRE_THROWS_WITH( createFullStateDiagMatr(62), ContainsSubstring("memory would overflow size_t") );
 
            // no overflows, but definitely exceeds local RAM and fails to allocate; frightens address sanitizer!
            // note the specific error message depends on the what backend the auto-deployer tried to use (e.g.
            // GPU-accel or distributed) and whether memory-probers realised there was insufficient memory in
            // advance or whether it proceeded to malloc() which subsequently failed
            #ifndef SANITIZER_IS_ACTIVE
            REQUIRE_THROWS_WITH( createFullStateDiagMatr(50), 
                ContainsSubstring("failed") || 
                ContainsSubstring("insufficient available memory") || 
                ContainsSubstring("available GPU memory") ||
                ContainsSubstring("exceeds the available RAM") ||
                ContainsSubstring("exceeds the local available RAM") );
            #endif
        }
 
        // this function chooses automatic deployment,
        // so we cannot force illegal distribution
    }
}

TEST_CASE() [5/24]

TEST_CASE	(	"createInlineCompMatr"	,
		TEST_CATEGORY	)

Definition at line 1220 of file matrices.cpp.

                                                   {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        CompMatr matr = createInlineCompMatr(1, {{1,2},{3,4}});
 
        REQUIRE_AGREE( matr, {{1,2},{3,4}} );
        REQUIRE( *(matr.wasGpuSynced) == 1 );
 
        destroyCompMatr(matr);
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "env not initialised" ) {
 
            // impossible to test
            SUCCEED( );
        }
 
        SECTION( "too few qubits" ) {
 
            int numQubits = GENERATE( -1, 0 );
 
            REQUIRE_THROWS_WITH( createInlineCompMatr(numQubits, {{1}}), ContainsSubstring("must target one or more qubits") );
        }
 
        SECTION( "mismatching dimension" ) {
 
            REQUIRE_THROWS_WITH( createInlineCompMatr(2, {{1,2},{3,4}}), ContainsSubstring("Incompatible number of rows") );
        }
    }
}

TEST_CASE() [6/24]

TEST_CASE	(	"createInlineDiagMatr"	,
		TEST_CATEGORY	)

Definition at line 1255 of file matrices.cpp.

                                                   {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        DiagMatr matr = createInlineDiagMatr(1, {1,2_i});
 
        REQUIRE_AGREE( matr, {{1,0},{0,2_i}} );
        REQUIRE( *(matr.wasGpuSynced) == 1 );
 
        destroyDiagMatr(matr);
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "env not initialised" ) {
 
            // impossible to test
            SUCCEED( );
        }
 
        SECTION( "too few qubits" ) {
 
            int numQubits = GENERATE( -1, 0 );
 
            REQUIRE_THROWS_WITH( createInlineDiagMatr(numQubits, {1}), ContainsSubstring("must target one or more qubits") );
        }
 
        SECTION( "mismatching dimension" ) {
 
            REQUIRE_THROWS_WITH( createInlineDiagMatr(2, {1,2}), ContainsSubstring("Incompatible number of elements") );
        }
    }
}

TEST_CASE() [7/24]

TEST_CASE	(	"destroyCompMatr"	,
		TEST_CATEGORY	)

Definition at line 739 of file matrices.cpp.

                                              {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        CompMatr m = createCompMatr(5);
        REQUIRE_NOTHROW( destroyCompMatr(m) );
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        // sanitizer messes with default initialisation
        #ifndef SANITIZER_IS_ACTIVE
        SECTION( "not created" ) {
 
            CompMatr m;
            REQUIRE_THROWS_WITH( destroyCompMatr(m), ContainsSubstring("Invalid CompMatr") && ContainsSubstring("not created") );
        }
        #endif
    }
}

TEST_CASE() [8/24]

TEST_CASE	(	"destroyDiagMatr"	,
		TEST_CATEGORY	)

Definition at line 761 of file matrices.cpp.

                                              {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        DiagMatr m = createDiagMatr(5);
        REQUIRE_NOTHROW( destroyDiagMatr(m) );
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        // sanitizer messes with default initialisation
        #ifndef SANITIZER_IS_ACTIVE
        SECTION( "not created" ) {
 
            DiagMatr m;
            REQUIRE_THROWS_WITH( destroyDiagMatr(m), ContainsSubstring("Invalid DiagMatr") && ContainsSubstring("not created") );
        }
        #endif
    }
}

TEST_CASE() [9/24]

TEST_CASE	(	"destroyFullStateDiagMatr"	,
		TEST_CATEGORY	)

Definition at line 783 of file matrices.cpp.

                                                       {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        FullStateDiagMatr m = createFullStateDiagMatr(5);
        REQUIRE_NOTHROW( destroyFullStateDiagMatr(m) );
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        // sanitizer messes with default initialisation
        #ifndef SANITIZER_IS_ACTIVE
        SECTION( "not created" ) {
 
            FullStateDiagMatr m;
            REQUIRE_THROWS_WITH( destroyFullStateDiagMatr(m), ContainsSubstring("Invalid FullStateDiagMatr") );
        }
        #endif
    }
}

TEST_CASE() [10/24]

TEST_CASE	(	"getCompMatr1"	,
		TEST_CATEGORY	)

TESTS

Definition at line 51 of file matrices.cpp.

                                           {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        constexpr int dim = 2;
        qmatrix ref = getRandomMatrix(dim);
 
        SECTION( LABEL_C_INTERFACE ) {
 
            // 2D compile-time array
            qcomp arr[dim][dim] = {{ref[0][0], ref[0][1]}, {ref[1][0], ref[1][1]}};
            REQUIRE_AGREE( getCompMatr1(arr), ref );
 
            // nested pointers
            qcomp** ptrs = (qcomp**) malloc(dim * sizeof *ptrs);
            for (int i=0; i<dim; i++) {
                ptrs[i] = (qcomp*) malloc(dim * sizeof **ptrs);
                for (int j=0; j<dim; j++)
                    ptrs[i][j] = ref[i][j];
            }
            REQUIRE_AGREE( getCompMatr1(ptrs), ref );
 
            // array of pointers
            qcomp* ptrArr[dim];
            for (int i=0; i<dim; i++)
                ptrArr[i] = ptrs[i];
            REQUIRE_AGREE( getCompMatr1(ptrArr), ref );
 
            // cleanup
            for (int i=0; i<dim; i++)
                free(ptrs[i]);
            free(ptrs);
        }
 
        SECTION( LABEL_CPP_INTERFACE ) {
 
            // nested vectors
            REQUIRE_AGREE( getCompMatr1(ref), ref );
 
            // inline vectors
            REQUIRE_AGREE( getCompMatr1({{ref[0][0],ref[0][1]},{ref[1][0],ref[1][1]}}), ref );
        }
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "null pointer" ) {
 
            qcomp** ptr = nullptr;
            REQUIRE_THROWS_WITH( getCompMatr1(ptr), ContainsSubstring("was a null pointer") );
 
            qcomp* arr[1] = {nullptr};
            REQUIRE_THROWS_WITH( getCompMatr1(arr), ContainsSubstring("contained a null pointer") );
        }
 
        SECTION( "invalid dimensions" ) {
 
            // detectable only by the C++ interface
 
            REQUIRE_THROWS_WITH( getCompMatr1({{0,0}}),             ContainsSubstring("Incompatible number of rows") );
            REQUIRE_THROWS_WITH( getCompMatr1({{0,0},{0,0},{0,0}}), ContainsSubstring("Incompatible number of rows") );
        
            REQUIRE_THROWS_WITH( getCompMatr1({{0,0},{0}}),     ContainsSubstring("incompatible number of elements") );
            REQUIRE_THROWS_WITH( getCompMatr1({{0,0},{0,0,0}}), ContainsSubstring("incompatible number of elements") );
        }
    }
}

TEST_CASE() [11/24]

TEST_CASE	(	"getCompMatr2"	,
		TEST_CATEGORY	)

Definition at line 120 of file matrices.cpp.

                                           {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        constexpr int dim = 4;
        qmatrix ref = getRandomMatrix(dim);
 
        SECTION( LABEL_C_INTERFACE ) {
 
            // 2D compile-time array
            qcomp arr[dim][dim];
            for (int i=0; i<dim; i++)
                for (int j=0; j<dim; j++)
                    arr[i][j] = ref[i][j];
            REQUIRE_AGREE( getCompMatr2(arr), ref );
 
            // nested pointers
            qcomp** ptrs = (qcomp**) malloc(dim * sizeof *ptrs);
            for (int i=0; i<dim; i++) {
                ptrs[i] = (qcomp*) malloc(dim * sizeof **ptrs);
                for (int j=0; j<dim; j++)
                    ptrs[i][j] = ref[i][j];
            }
            REQUIRE_AGREE( getCompMatr2(ptrs), ref );
 
            // array of pointers
            qcomp* ptrArr[dim];
            for (int i=0; i<dim; i++)
                ptrArr[i] = ptrs[i];
            REQUIRE_AGREE( getCompMatr2(ptrArr), ref );
 
            // cleanup
            for (int i=0; i<dim; i++)
                free(ptrs[i]);
            free(ptrs);
        }
 
        SECTION( LABEL_CPP_INTERFACE ) {
 
            // nested vectors
            REQUIRE_AGREE( getCompMatr2(ref), ref );
 
            // inline vectors
            REQUIRE_AGREE( 
                getCompMatr2({
                    {ref[0][0],ref[0][1],ref[0][2],ref[0][3]},
                    {ref[1][0],ref[1][1],ref[1][2],ref[1][3]},
                    {ref[2][0],ref[2][1],ref[2][2],ref[2][3]},
                    {ref[3][0],ref[3][1],ref[3][2],ref[3][3]}
                }),
                ref
            );
        }
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "null pointer" ) {
 
            qcomp** ptr = nullptr;
            REQUIRE_THROWS_WITH( getCompMatr2(ptr), ContainsSubstring("was a null pointer") );
 
            qcomp* arr[1] = {nullptr};
            REQUIRE_THROWS_WITH( getCompMatr2(arr), ContainsSubstring("contained a null pointer") );
        }
 
        SECTION( "invalid dimensions" ) {
 
            // detectable only by the C++ interface
 
            qmatrix bad1 = {{0,0,0,0}};
            qmatrix bad2 = {{0,0,0,0},{0,0,0,0},{0,0,0,0}};
 
            REQUIRE_THROWS_WITH( getCompMatr2(bad1), ContainsSubstring("Incompatible number of rows") );
            REQUIRE_THROWS_WITH( getCompMatr2(bad2), ContainsSubstring("Incompatible number of rows") );
        
            REQUIRE_THROWS_WITH( getCompMatr2({{0,0,0,0},{0},{0},{0}}),   ContainsSubstring("incompatible number of elements") );
            REQUIRE_THROWS_WITH( getCompMatr2({{0,0,0,0,0},{0},{0},{0}}), ContainsSubstring("incompatible number of elements") );
        }
    }
}

TEST_CASE() [12/24]

TEST_CASE	(	"getDiagMatr1"	,
		TEST_CATEGORY	)

Definition at line 203 of file matrices.cpp.

                                           {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        constexpr int dim = 2;
        qmatrix ref = getRandomDiagonalMatrix(dim);
 
        SECTION( LABEL_C_INTERFACE ) {
 
            // compile-time array
            qcomp arr[dim] = {ref[0][0], ref[1][1] };
            REQUIRE_AGREE( getDiagMatr1(arr), ref );
 
            // pointer
            qvector diags = getDiagonals(ref);
            REQUIRE_AGREE( getDiagMatr1(diags.data()), ref );
        }
 
        SECTION( LABEL_CPP_INTERFACE ) {
 
            // inline vectors
            REQUIRE_AGREE( getDiagMatr1({ref[0][0],ref[1][1]}), ref );
        }
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "null pointer" ) {
 
            qcomp* ptr = nullptr;
            REQUIRE_THROWS_WITH( getDiagMatr1(ptr), ContainsSubstring("was a null pointer") );
        }
 
        SECTION( "invalid dimensions" ) {
 
            // detectable only by the C++ interface
            qvector bad1 = {0};
            qvector bad2 = {0,0,0};
 
            REQUIRE_THROWS_WITH( getDiagMatr1(bad1), ContainsSubstring("Incompatible number of elements") );
            REQUIRE_THROWS_WITH( getDiagMatr1(bad2), ContainsSubstring("Incompatible number of elements") );
        }
    }
}

TEST_CASE() [13/24]

TEST_CASE	(	"getDiagMatr2"	,
		TEST_CATEGORY	)

Definition at line 249 of file matrices.cpp.

                                           {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        constexpr int dim = 4;
        qmatrix ref = getRandomDiagonalMatrix(dim);
 
        SECTION( LABEL_C_INTERFACE ) {
 
            // compile-time array
            qcomp arr[dim] = {ref[0][0], ref[1][1], ref[2][2], ref[3][3] };
            REQUIRE_AGREE( getDiagMatr2(arr), ref );
 
            // pointer
            qvector diags = getDiagonals(ref);
            REQUIRE_AGREE( getDiagMatr2(diags.data()), ref );
        }
 
        SECTION( LABEL_CPP_INTERFACE ) {
 
            // inline vectors
            REQUIRE_AGREE( getDiagMatr2({ref[0][0], ref[1][1], ref[2][2], ref[3][3] }), ref );
        }
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "null pointer" ) {
 
            qcomp* ptr = nullptr;
            REQUIRE_THROWS_WITH( getDiagMatr2(ptr), ContainsSubstring("was a null pointer") );
        }
 
        SECTION( "invalid dimensions" ) {
 
            // detectable only by the C++ interface
            qvector bad1 = {0,0,0};
            qvector bad2 = {0,0,0,0,0};
 
            REQUIRE_THROWS_WITH( getDiagMatr2(bad1), ContainsSubstring("Incompatible number of elements") );
            REQUIRE_THROWS_WITH( getDiagMatr2(bad2), ContainsSubstring("Incompatible number of elements") );
        }
    }
}

TEST_CASE() [14/24]

TEST_CASE	(	"getInlineCompMatr1"	,
		TEST_CATEGORY	)

Definition at line 295 of file matrices.cpp.

                                                 {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        qmatrix ref = {{1,2},{3_i,4_i}};
 
        REQUIRE_AGREE( getInlineCompMatr1({{1,2},{3_i,4_i}}), ref );
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "invalid dimensions" ) {
 
            // detectable only by the C++ interface
 
            REQUIRE_THROWS_WITH( getInlineCompMatr1({{0,0}}),             ContainsSubstring("Incompatible number of rows") );
            REQUIRE_THROWS_WITH( getInlineCompMatr1({{0,0},{0,0},{0,0}}), ContainsSubstring("Incompatible number of rows") );
        
            REQUIRE_THROWS_WITH( getInlineCompMatr1({{0,0},{0}}),     ContainsSubstring("incompatible number of elements") );
            REQUIRE_THROWS_WITH( getInlineCompMatr1({{0,0},{0,0,0}}), ContainsSubstring("incompatible number of elements") );
        }
    }
}

TEST_CASE() [15/24]

TEST_CASE	(	"getInlineCompMatr2"	,
		TEST_CATEGORY	)

Definition at line 320 of file matrices.cpp.

                                                 {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        qmatrix ref = {
            {1,2,3,4},
            {5_i,6_i,7_i,8_i},
            {-1,-2,-3,-4},
            {-1_i,-2_i,-3_i,-4_i}};
 
        REQUIRE_AGREE( 
            getInlineCompMatr2({
                {1,2,3,4},
                {5_i,6_i,7_i,8_i},
                {-1,-2,-3,-4},
                {-1_i,-2_i,-3_i,-4_i}
            }), ref );
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "invalid dimensions" ) {
 
            // detectable only by the C++ interface
 
            REQUIRE_THROWS_WITH( getInlineCompMatr2({{0,0,0,0}}),                     ContainsSubstring("Incompatible number of rows") );
            REQUIRE_THROWS_WITH( getInlineCompMatr2({{0,0,0,0},{0,0,0,0},{0,0,0,0}}), ContainsSubstring("Incompatible number of rows") );
        
            REQUIRE_THROWS_WITH( getInlineCompMatr2({{0,0,0,0},{0},{0},{0}}),   ContainsSubstring("incompatible number of elements") );
            REQUIRE_THROWS_WITH( getInlineCompMatr2({{0,0,0,0,0},{0},{0},{0}}), ContainsSubstring("incompatible number of elements") );
        }
    }
}

TEST_CASE() [16/24]

TEST_CASE	(	"getInlineDiagMatr1"	,
		TEST_CATEGORY	)

Definition at line 355 of file matrices.cpp.

                                                 {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        qmatrix ref = getDiagonalMatrix({1,2_i});
 
        REQUIRE_AGREE( getInlineDiagMatr1({1,2_i}), ref );
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "invalid dimensions" ) {
 
            REQUIRE_THROWS_WITH( getInlineDiagMatr1({0,0,0}), ContainsSubstring("Incompatible number of elements") );
        }
    }
}

TEST_CASE() [17/24]

TEST_CASE	(	"getInlineDiagMatr2"	,
		TEST_CATEGORY	)

Definition at line 374 of file matrices.cpp.

                                                 {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        qmatrix ref = getDiagonalMatrix({1,2_i,-3,-4_i});
 
        REQUIRE_AGREE( getInlineDiagMatr2({1,2_i,-3,-4_i}), ref );
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        SECTION( "invalid dimensions" ) {
 
            REQUIRE_THROWS_WITH( getInlineDiagMatr2({0,0,0}),     ContainsSubstring("Incompatible number of elements") );
            REQUIRE_THROWS_WITH( getInlineDiagMatr2({0,0,0,0,0}), ContainsSubstring("Incompatible number of elements") );
        }
    }
}

TEST_CASE() [18/24]

TEST_CASE	(	"setCompMatr"	,
		TEST_CATEGORY	)

Definition at line 958 of file matrices.cpp.

                                          {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numQubits = GENERATE( range(1,6) );
        CAPTURE( numQubits );
 
        CompMatr matr = createCompMatr(numQubits);
        REQUIRE( *(matr.wasGpuSynced) == 0 );
 
        int dim = getPow2(numQubits);
        qmatrix ref = getRandomMatrix(dim);
 
        SECTION( LABEL_C_INTERFACE ) {
 
            // nested pointers
            qcomp** ptrs = (qcomp**) malloc(dim * sizeof *ptrs);
            for (int i=0; i<dim; i++) {
                ptrs[i] = (qcomp*) malloc(dim * sizeof **ptrs);
                for (int j=0; j<dim; j++)
                    ptrs[i][j] = ref[i][j];
            }
            setCompMatr(matr, ptrs);
            REQUIRE_AGREE( matr, ref );
            REQUIRE( *(matr.wasGpuSynced) == 1 );
 
            // cannot test 2D VLAs in this C++ file
 
            // cleanup
            for (int i=0; i<dim; i++)
                free(ptrs[i]);
            free(ptrs);
        }
 
        SECTION( LABEL_CPP_INTERFACE ) {
 
            // nested vectors
            setCompMatr( matr, getZeroMatrix(dim) ); // clear
            setCompMatr( matr, ref );
            REQUIRE_AGREE( matr, ref );
            REQUIRE( *(matr.wasGpuSynced) == 1 );
        }
 
        destroyCompMatr(matr);
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        CompMatr matr = createCompMatr(1);
 
        /// @todo fails in MSVC for unknown reason
        #ifndef _MSC_VER
        // sanitizer messes with default initialisation
        #ifndef SANITIZER_IS_ACTIVE
        SECTION( "not created" ) {
 
            CompMatr bad;
            qcomp** dummy;
            REQUIRE_THROWS_WITH( setCompMatr(bad, dummy), ContainsSubstring("Invalid CompMatr") && ContainsSubstring("not created") );
        }
        #endif
        #endif
 
        SECTION( "null pointer" ) {
 
            qcomp** ptr = nullptr;
            REQUIRE_THROWS_WITH( setCompMatr(matr, ptr), ContainsSubstring("was a null pointer") );
 
            qcomp* arr[1] = {nullptr};
            REQUIRE_THROWS_WITH( setCompMatr(matr, arr), ContainsSubstring("contained a null pointer") );
        }
 
        SECTION( "invalid dimensions" ) {
 
            // detectable only by the C++ interface
 
            REQUIRE_NOTHROW( setCompMatr(matr, {{1,2},{3,4}}) );
 
            REQUIRE_THROWS_WITH( setCompMatr(matr,{{1,2}}),              ContainsSubstring("Incompatible number of rows") );
            REQUIRE_THROWS_WITH( setCompMatr(matr, {{1,2},{3,4},{5,6}}), ContainsSubstring("Incompatible number of rows") );
        
            REQUIRE_THROWS_WITH( setCompMatr(matr, {{0,0},{0}}),     ContainsSubstring("incompatible number of elements") );
            REQUIRE_THROWS_WITH( setCompMatr(matr, {{0,0},{0,0,0}}), ContainsSubstring("incompatible number of elements") );
        }
 
        destroyCompMatr(matr);
    }
}

TEST_CASE() [19/24]

TEST_CASE	(	"setDiagMatr"	,
		TEST_CATEGORY	)

Definition at line 1048 of file matrices.cpp.

                                          {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        int numQubits = GENERATE( range(1,6) );
        CAPTURE( numQubits );
 
        DiagMatr matr = createDiagMatr(numQubits);
        REQUIRE( *(matr.wasGpuSynced) == 0 );
 
        int dim = getPow2(numQubits);
        qmatrix ref = getRandomDiagonalMatrix(dim);
 
        SECTION( LABEL_C_INTERFACE ) {
 
            // pointer
            qvector diags = getDiagonals(ref);
            setDiagMatr(matr, diags.data());
            REQUIRE_AGREE( matr, ref );
            REQUIRE( *(matr.wasGpuSynced) == 1 );
        }
 
        SECTION( LABEL_CPP_INTERFACE ) {
 
            // vector
            setDiagMatr(matr, getZeroVector(dim)); // clear
            setDiagMatr(matr, getDiagonals(ref));
            REQUIRE_AGREE( matr, ref );
            REQUIRE( *(matr.wasGpuSynced) == 1 );
        }
 
        destroyDiagMatr(matr);
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        DiagMatr matr = createDiagMatr(1);
 
        // sanitizer messes with default initialisation
        #ifndef SANITIZER_IS_ACTIVE
        SECTION( "not created" ) {
 
            DiagMatr bad;
            qcomp* dummy;
            REQUIRE_THROWS_WITH( setDiagMatr(bad, dummy), ContainsSubstring("Invalid DiagMatr") && ContainsSubstring("not created") );
        }
        #endif
 
        SECTION( "null pointer" ) {
 
            qcomp* ptr = nullptr;
            REQUIRE_THROWS_WITH( setDiagMatr(matr, ptr), ContainsSubstring("was a null pointer") );
        }
 
        SECTION( "invalid dimensions" ) {
 
            // detectable only by the C++ interface
 
            REQUIRE_NOTHROW( setDiagMatr(matr, {1,2}) );
 
            REQUIRE_THROWS_WITH( setDiagMatr(matr, {1}),     ContainsSubstring("Incompatible number of elements") );
            REQUIRE_THROWS_WITH( setDiagMatr(matr, {1,2,3}), ContainsSubstring("Incompatible number of elements") );
        }
 
        destroyDiagMatr(matr);
    }
}

TEST_CASE() [20/24]

TEST_CASE	(	"setInlineCompMatr"	,
		TEST_CATEGORY	)

Definition at line 1117 of file matrices.cpp.

                                                {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        CompMatr matr = createCompMatr(1);
        REQUIRE( *(matr.wasGpuSynced) == 0 );
 
        setInlineCompMatr( matr, 1, {{1,2},{3,4}} );
        REQUIRE_AGREE( matr, {{1,2},{3,4}} );
        REQUIRE( *(matr.wasGpuSynced) == 1 );
 
        destroyCompMatr(matr);
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        CompMatr matr = createCompMatr(1);
 
        /// @todo fails in MSVC for unknown reason
        #ifndef _MSC_VER
        // sanitizer messes with default initialisation
        #ifndef SANITIZER_IS_ACTIVE
        SECTION( "not created" ) {
 
            CompMatr bad;
            REQUIRE_THROWS_WITH( setInlineCompMatr(bad, 1, {{1,2},{3,4}}), ContainsSubstring("Invalid CompMatr") && ContainsSubstring("not created") );
        }
        #endif
        #endif
 
        SECTION( "mismatching dimension" ) {
 
            REQUIRE_THROWS_WITH( setInlineCompMatr(matr, 2, {{1,2},{3,4}}), ContainsSubstring("declared number of qubits") && ContainsSubstring("differs") );
        }
 
        SECTION( "invalid dimensions" ) {
 
            // detectable only by the C++ interface
 
            REQUIRE_NOTHROW( setInlineCompMatr(matr, 1, {{1,2},{3,4}}) );
 
            REQUIRE_THROWS_WITH( setInlineCompMatr(matr, 1, {{1,2}}),             ContainsSubstring("Incompatible number of rows") );
            REQUIRE_THROWS_WITH( setInlineCompMatr(matr, 1, {{1,2},{3,4},{5,6}}), ContainsSubstring("Incompatible number of rows") );
 
            REQUIRE_THROWS_WITH( setInlineCompMatr(matr, 1, {{1},{2}}),         ContainsSubstring("One or more rows contained an incompatible number of elements") );
            REQUIRE_THROWS_WITH( setInlineCompMatr(matr, 1, {{1,2,3},{4,5,6}}), ContainsSubstring("One or more rows contained an incompatible number of elements") );
        }
 
        destroyCompMatr(matr);
    }
}

TEST_CASE() [21/24]

TEST_CASE	(	"setInlineDiagMatr"	,
		TEST_CATEGORY	)

Definition at line 1170 of file matrices.cpp.

                                                {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        DiagMatr matr = createDiagMatr(1);
        REQUIRE( *(matr.wasGpuSynced) == 0 );
 
        setInlineDiagMatr( matr, 1, {1,2_i} );
        REQUIRE_AGREE( matr, {{1,0},{0,2_i}} );
        REQUIRE( *(matr.wasGpuSynced) == 1 );
 
        destroyDiagMatr(matr);
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        DiagMatr matr = createDiagMatr(1);
 
        /// @todo fails in MSVC for unknown reason
        #ifndef _MSC_VER
        // sanitizer messes with default initialisation
        #ifndef SANITIZER_IS_ACTIVE
        SECTION( "not created" ) {
 
            DiagMatr bad;
            REQUIRE_THROWS_WITH( setInlineDiagMatr(bad, 1, {1,2}), ContainsSubstring("Invalid DiagMatr") && ContainsSubstring("not created") );
        }
        #endif
        #endif
 
        SECTION( "mismatching dimension" ) {
 
            REQUIRE_THROWS_WITH( setInlineDiagMatr(matr, 2, {1,2}), ContainsSubstring("declared number of qubits") && ContainsSubstring("differs") );
        }
 
        SECTION( "invalid dimensions" ) {
 
            // detectable only by the C++ interface
 
            REQUIRE_NOTHROW( setInlineDiagMatr(matr, 1, {1,2}) );
 
            REQUIRE_THROWS_WITH( setInlineDiagMatr(matr, 1, {1}),     ContainsSubstring("Incompatible number of elements") );
            REQUIRE_THROWS_WITH( setInlineDiagMatr(matr, 1, {1,2,3}), ContainsSubstring("Incompatible number of elements") );
        }
 
        destroyDiagMatr(matr);
    }
}

TEST_CASE() [22/24]

TEST_CASE	(	"syncCompMatr"	,
		TEST_CATEGORY	)

Definition at line 805 of file matrices.cpp.

                                           {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        CompMatr matr = createCompMatr(5);
 
        REQUIRE( *(matr.wasGpuSynced) == 0 );
 
        SECTION( "overwrites GPU elements" ) {
 
            // to test that the GPU memory was actually overwritten,
            // we would need a custom accessor of GPU memory, requiring
            // the tests are CUDA-compiled - no thank you mam! It is
            // certain this function works from the other GPU tests.
 
            SUCCEED( );
        }
 
        SECTION( "sets was-synced flag" ) {
 
            *(matr.wasGpuSynced) = 0;
 
            syncCompMatr(matr);
            REQUIRE( *(matr.wasGpuSynced) == 1 );
        }
 
        SECTION( "clears numerical flags" ) {
 
            *(matr).isApproxHermitian = 1;
            *(matr).isApproxUnitary   = 0;
 
            syncCompMatr(matr);
            REQUIRE( *(matr.isApproxHermitian) == -1 );
            REQUIRE( *(matr.isApproxUnitary)   == -1 );
        }
 
        destroyCompMatr(matr);
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        // sanitizer messes with default initialisation
        #ifndef SANITIZER_IS_ACTIVE
        SECTION( "not created" ) {
 
            CompMatr m;
            REQUIRE_THROWS_WITH( syncCompMatr(m), ContainsSubstring("Invalid CompMatr") && ContainsSubstring("not created") );
        }
        #endif
    }
}

TEST_CASE() [23/24]

TEST_CASE	(	"syncDiagMatr"	,
		TEST_CATEGORY	)

Definition at line 858 of file matrices.cpp.

                                           {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        DiagMatr matr = createDiagMatr(5);
        REQUIRE( *(matr.wasGpuSynced) == 0 );
 
        SECTION( "overwrites GPU elements" ) {
 
            // to test that the GPU memory was actually overwritten,
            // we would need a custom accessor of GPU memory, requiring
            // the tests are CUDA-compiled - no thank you mam! It is
            // certain this function works from the other GPU tests.
 
            SUCCEED( );
        }
 
        SECTION( "sets was-synced flag" ) {
 
            *(matr.wasGpuSynced) = 0;
 
            syncDiagMatr(matr);
            REQUIRE( *(matr.wasGpuSynced) == 1 );
        }
 
        SECTION( "clears numerical flags" ) {
 
            *(matr).isApproxHermitian = 1;
            *(matr).isApproxUnitary   = 0;
            *(matr).isApproxNonZero   = 1;
            *(matr).isStrictlyNonNegative = 0;
 
            syncDiagMatr(matr);
            REQUIRE( *(matr.isApproxHermitian) == -1 );
            REQUIRE( *(matr.isApproxUnitary)   == -1 );
            REQUIRE( *(matr.isApproxNonZero)   == -1 );
            REQUIRE( *(matr.isStrictlyNonNegative) == -1 );
        }
 
        destroyDiagMatr(matr);
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        // sanitizer messes with default initialisation
        #ifndef SANITIZER_IS_ACTIVE
        SECTION( "not created" ) {
 
            DiagMatr m;
            REQUIRE_THROWS_WITH( syncDiagMatr(m), ContainsSubstring("Invalid DiagMatr") && ContainsSubstring("not created") );
        }
        #endif
    }
}

TEST_CASE() [24/24]

TEST_CASE	(	"syncFullStateDiagMatr"	,
		TEST_CATEGORY	)

Definition at line 914 of file matrices.cpp.

                                                    {
 
    SECTION( LABEL_CORRECTNESS ) {
 
        for (auto& [label, matrix]: getCachedFullStateDiagMatrs()) {
 
            DYNAMIC_SECTION( label ) {
 
                *(matrix.wasGpuSynced) = 0;
                *(matrix).isApproxHermitian = 1;
                *(matrix).isApproxUnitary   = 0;
                *(matrix).isApproxNonZero   = 1;
                *(matrix).isStrictlyNonNegative = 0;
 
                syncFullStateDiagMatr(matrix);
                REQUIRE( *(matrix.wasGpuSynced)      == 1 );
                
                REQUIRE( *(matrix.isApproxHermitian) == -1 );
                REQUIRE( *(matrix.isApproxUnitary)   == -1 );
                REQUIRE( *(matrix.isApproxNonZero)   == -1 );
                REQUIRE( *(matrix.isStrictlyNonNegative) == -1 );
 
                // to test that the GPU memory was actually overwritten,
                // we would need a custom accessor of GPU memory, requiring
                // the tests are CUDA-compiled - no thank you mam! It is
                // certain this function works from the other GPU tests.
            }
        }
    }
 
    SECTION( LABEL_VALIDATION ) {
 
        // sanitizer messes with default initialisation
        #ifndef SANITIZER_IS_ACTIVE
        SECTION( "not created" ) {
 
            FullStateDiagMatr m;
            REQUIRE_THROWS_WITH( syncFullStateDiagMatr(m), ContainsSubstring("Invalid FullStateDiagMatr") );
        }
        #endif
    }
}