state.cpp File Reference

#include "qengine_cpu.hpp"
#include <chrono>
#include <thread>

Include dependency graph for state.cpp:

Namespaces
	Qrack

Macros
#define	CHECK_ZERO_SKIP()
#define	NORM_THRESH_KERNEL(fn1, fn2)
	Apply a 2x2 matrix to the state vector. More...
#define	NORM_CALC_KERNEL(fn1, fn2)

Macro Definition Documentation

CHECK_ZERO_SKIP

#define CHECK_ZERO_SKIP

(

)

Value:

    if (!stateVec) {                                                                                                   \
        return;                                                                                                        \
    }

NORM_CALC_KERNEL

#define NORM_CALC_KERNEL	(		fn1,
			fn2
	)

Value:

    [&](const bitCapIntOcl& lcv, const unsigned& cpu) {                                                                \
        complex qubit[2U];                                                                                             \
                                                                                                                       \
        const complex Y0 = stateVec->read(lcv + offset1);                                                              \
        qubit[1U] = stateVec->read(lcv + offset2);                                                                     \
                                                                                                                       \
        qubit[0U] = fn1;                                                                                               \
        qubit[1U] = fn2;                                                                                               \
                                                                                                                       \
        rngNrm[cpu] = norm(qubit[0U]) + norm(qubit[1U]);                                                               \
                                                                                                                       \
        stateVec->write2(lcv + offset1, qubit[0U], lcv + offset2, qubit[1U]);                                          \
    };

NORM_THRESH_KERNEL

#define NORM_THRESH_KERNEL	(		fn1,
			fn2
	)

Value:

    [&](const bitCapIntOcl& lcv, const unsigned& cpu) {                                                                \
        complex qubit[2U];                                                                                             \
                                                                                                                       \
        const complex Y0 = stateVec->read(lcv + offset1);                                                              \
        qubit[1U] = stateVec->read(lcv + offset2);                                                                     \
                                                                                                                       \
        qubit[0U] = fn1;                                                                                               \
        qubit[1U] = fn2;                                                                                               \
                                                                                                                       \
        real1 dotMulRes = norm(qubit[0U]);                                                                             \
        if (dotMulRes < norm_thresh) {                                                                                 \
            qubit[0U] = ZERO_CMPLX;                                                                                    \
        } else {                                                                                                       \
            rngNrm[cpu] += dotMulRes;                                                                                  \
        }                                                                                                              \
                                                                                                                       \
        dotMulRes = norm(qubit[1U]);                                                                                   \
        if (dotMulRes < norm_thresh) {                                                                                 \
            qubit[1U] = ZERO_CMPLX;                                                                                    \
        } else {                                                                                                       \
            rngNrm[cpu] += dotMulRes;                                                                                  \
        }                                                                                                              \
        stateVec->write2(lcv + offset1, qubit[0U], lcv + offset2, qubit[1U]);                                          \
    }

Apply a 2x2 matrix to the state vector.

A fundamental operation used by almost all gates.