Functions for creating variable-size matrices. More...

Functions
CompMatr	createCompMatr (int numQubits)

FullStateDiagMatr	createCustomFullStateDiagMatr (int numQubits, int useDistrib, int useGpuAccel, int useMultithread)

DiagMatr	createDiagMatr (int numQubits)

FullStateDiagMatr	createFullStateDiagMatr (int numQubits)

FullStateDiagMatr	createFullStateDiagMatrFromPauliStrSum (PauliStrSum in)

CompMatr	createInlineCompMatr (int numQb, {{ matrix }})

DiagMatr	createInlineDiagMatr (int numQb, { list })

Detailed Description

Functions for creating variable-size matrices.

Function Documentation

◆ createCompMatr()

CompMatr createCompMatr ( int numQubits )

Note: Documentation for this function or struct is under construction!

See also

Definition at line 213 of file matrices.cpp.

                                                  {
    validate_envIsInit(__func__);
    validate_newCompMatrParams(numQubits, __func__);
 
    // validation ensures these never overflow
    qindex numRows = powerOf2(numQubits);
    qindex numElems = numRows * numRows;
 
    // attempt to allocate 1D memory
    qcomp* cpuMem = cpu_allocArray(numElems); // nullptr if failed
    qcomp* gpuMem = nullptr;
    if (getQuESTEnv().isGpuAccelerated)
        gpuMem = gpu_allocArray(numElems); // nullptr if failed
 
    // prepare output CompMatr (avoiding C++20 designated initialiser)
    CompMatr out;
    out.numQubits = numQubits;
    out.numRows = numRows;
 
    // attemptedly allocate (un-initialised) flags in the heap so that struct copies are mutable
    out.isApproxUnitary    = util_allocEpsilonSensitiveHeapFlag(); // nullptr if failed
    out.isApproxHermitian  = util_allocEpsilonSensitiveHeapFlag();
    out.wasGpuSynced = cpu_allocHeapFlag(); // nullptr if failed
 
    // attemptedly allocate 2D alias for 1D CPU memory
    out.cpuElems = cpu_allocAndInitMatrixWrapper(cpuMem, numRows); // nullptr if failed
    out.cpuElemsFlat = cpuMem;
    out.gpuElemsFlat = gpuMem;
 
    validateMatrixAllocs(out, __func__);
    setInitialHeapFlags(out);
    return out;
}

Referenced by TEST_CASE(), TEST_CASE(), TEST_CASE(), and TEST_CASE().

◆ createCustomFullStateDiagMatr()

FullStateDiagMatr createCustomFullStateDiagMatr	(	int	numQubits,
		int	useDistrib,
		int	useGpuAccel,
		int	useMultithread )

Note: Documentation for this function or struct is under construction!

See also

Definition at line 318 of file matrices.cpp.

                                                                                                                               {
 
    return validateAndCreateCustomFullStateDiagMatr(numQubits, useDistrib, useGpuAccel, useMultithread, __func__);
}

Referenced by TEST_CASE().

◆ createDiagMatr()

DiagMatr createDiagMatr ( int numQubits )

Note: Documentation for this function or struct is under construction!

See also

Definition at line 248 of file matrices.cpp.

                                                  {
    validate_envIsInit(__func__);
    validate_newDiagMatrParams(numQubits, __func__);
 
    // validation ensures this never overflows
    qindex numElems = powerOf2(numQubits);
 
    // prepare output DiagMatr (avoiding C++20 designated initialiser)
    DiagMatr out;
    out.numQubits = numQubits,
    out.numElems = numElems,
 
    // attempt to allocate (uninitialised) flags in the heap so that struct copies are mutable
    out.isApproxUnitary       = util_allocEpsilonSensitiveHeapFlag(); // nullptr if failed
    out.isApproxHermitian     = util_allocEpsilonSensitiveHeapFlag();
    out.isApproxNonZero       = util_allocEpsilonSensitiveHeapFlag();
    out.isStrictlyNonNegative = cpu_allocHeapFlag(); // nullptr if failed
    out.wasGpuSynced          = cpu_allocHeapFlag();
 
    // attempt to allocate 1D memory (nullptr if failed or not allocated)
    out.cpuElems = cpu_allocArray(numElems);
    out.gpuElems = (getQuESTEnv().isGpuAccelerated)? gpu_allocArray(numElems) : nullptr;
 
    validateMatrixAllocs(out, __func__);
    setInitialHeapFlags(out);
    return out;
}

Referenced by TEST_CASE(), and TEST_CASE().

◆ createFullStateDiagMatr()

FullStateDiagMatr createFullStateDiagMatr ( int numQubits )

Note: Documentation for this function or struct is under construction!

See also

Definition at line 323 of file matrices.cpp.

                                                                    {
 
    return validateAndCreateCustomFullStateDiagMatr(numQubits, modeflag::USE_AUTO, modeflag::USE_AUTO, modeflag::USE_AUTO, __func__);
}

Referenced by createFullStateDiagMatrFromPauliStrSum(), and TEST_CASE().

◆ createFullStateDiagMatrFromPauliStrSum()

FullStateDiagMatr createFullStateDiagMatrFromPauliStrSum ( PauliStrSum in )

Note: Documentation for this function or struct is under construction!

Warning: This function has not yet been unit tested and may contain bugs. Please use with caution!

Definition at line 651 of file matrices.cpp.

                                                                                    {
    validate_pauliStrSumFields(in, __func__);
    
    // ensure createFullStateDiagMatr() below succeeds (so if not, that thrower name is correct)
    int numQubits = 1 + paulis_getIndOfLefmostNonIdentityPauli(in);
    validate_newFullStateDiagMatrParams(numQubits, modeflag::USE_AUTO, modeflag::USE_AUTO, modeflag::USE_AUTO, __func__);
 
    // permit 'in' to be non-Hermitian since it does not determine 'out' unitarity
 
    FullStateDiagMatr out = createFullStateDiagMatr(numQubits);
    localiser_fullstatediagmatr_setElemsToPauliStrSum(out, in);
    markMatrixAsSynced(out);
    return out;
}

◆ createInlineCompMatr()

CompMatr createInlineCompMatr	(	int	numQb,
		{{ matrix }}	)

Note: Documentation for this function or struct is under construction!; This entity is actually a macro.

See also

reportCompMatr()
C examples

◆ createInlineDiagMatr()

DiagMatr createInlineDiagMatr	(	int	numQb,
		{ list }	)

Note: Documentation for this function or struct is under construction!; This entity is actually a macro.

See also

reportDiagMatr()
C examples