Qrack  10.0
General classical-emulating-quantum development framework
Namespaces | Macros
qunit.cpp File Reference
#include "qengine_gpu_util.hpp"
#include "qfactory.hpp"
#include <ctime>
#include <initializer_list>
#include <map>
Include dependency graph for qunit.cpp:

Namespaces

 Qrack
 GLOSSARY: bitLenInt - "bit-length integer" - unsigned integer ID of qubit position in register bitCapInt - "bit-capacity integer" - unsigned integer single-permutation value of a qubit register (typically "big integer") real1 - "real number (1-dimensional)" - floating-point real-valued number complex - "complex number" - floating-point complex-valued number (with two real1 component dimensions) quid - "quantum (simulator) unique identifier" - unsigned integer that indexes and IDs running simulators, circuits, and neurons.
 

Macros

#define DIRTY(shard)   (shard.isPhaseDirty || shard.isProbDirty)
 
#define IS_1_CMPLX(c)   (norm(ONE_CMPLX - (c)) <= FP_NORM_EPSILON)
 
#define SHARD_STATE(shard)   ((2 * norm(shard.amp0)) < ONE_R1)
 
#define QUEUED_PHASE(shard)
 
#define CACHED_X(shard)   ((shard.pauliBasis == PauliX) && !DIRTY(shard) && !QUEUED_PHASE(shard))
 
#define CACHED_X_OR_Y(shard)   ((shard.pauliBasis != PauliZ) && !DIRTY(shard) && !QUEUED_PHASE(shard))
 
#define CACHED_Z(shard)   ((shard.pauliBasis == PauliZ) && !DIRTY(shard) && !QUEUED_PHASE(shard))
 
#define CACHED_ZERO(q)
 
#define CACHED_ONE(q)
 
#define CACHED_PLUS(q)
 
#define UNSAFE_CACHED_ZERO_OR_ONE(shard)    (!shard.isProbDirty && (shard.pauliBasis == PauliZ) && (IS_NORM_0(shard.amp0) || IS_NORM_0(shard.amp1)))
 
#define UNSAFE_CACHED_X(shard)    (!shard.isProbDirty && (shard.pauliBasis == PauliX) && (IS_NORM_0(shard.amp0) || IS_NORM_0(shard.amp1)))
 
#define UNSAFE_CACHED_ONE(shard)   (!shard.isProbDirty && (shard.pauliBasis == PauliZ) && IS_NORM_0(shard.amp0))
 
#define UNSAFE_CACHED_ZERO(shard)   (!shard.isProbDirty && (shard.pauliBasis == PauliZ) && IS_NORM_0(shard.amp1))
 
#define IS_SAME_UNIT(shard1, shard2)   (shard1.unit && (shard1.unit == shard2.unit))
 
#define ARE_CLIFFORD(shard1, shard2)    ((engines[0U] == QINTERFACE_STABILIZER_HYBRID) && shard1.isClifford() && shard2.isClifford())
 
#define BLOCKED_SEPARATE(shard)   (shard.unit && shard.unit->isClifford() && !shard.unit->TrySeparate(shard.mapped))
 
#define IS_PHASE_OR_INVERT(mtrx)    ((IS_NORM_0(mtrx[1U]) && IS_NORM_0(mtrx[2U])) || (IS_NORM_0(mtrx[0U]) && IS_NORM_0(mtrx[3U])))
 
#define CTRLED_GEN_WRAP(ctrld)
 
#define CTRLED_PHASE_INVERT_WRAP(ctrld, ctrldgen, isInvert, top, bottom)
 
#define CTRLED_SWAP_WRAP(ctrld, bare, anti)
 
#define CTRL_GEN_ARGS   mappedControls, trnsMtrx, shards[target].mapped, controlPerm
 
#define CTRL_S_ARGS   mappedControls, shards[qubit1].mapped, shards[qubit2].mapped
 
#define CTRL_P_ARGS   mappedControls, topLeft, bottomRight, shards[target].mapped, controlPerm
 
#define CTRL_I_ARGS   mappedControls, topRight, bottomLeft, shards[target].mapped, controlPerm
 

Macro Definition Documentation

◆ ARE_CLIFFORD

#define ARE_CLIFFORD (   shard1,
  shard2 
)     ((engines[0U] == QINTERFACE_STABILIZER_HYBRID) && shard1.isClifford() && shard2.isClifford())

◆ BLOCKED_SEPARATE

#define BLOCKED_SEPARATE (   shard)    (shard.unit && shard.unit->isClifford() && !shard.unit->TrySeparate(shard.mapped))

◆ CACHED_ONE

#define CACHED_ONE (   q)
Value:
(CACHED_Z(shards[q]) && !(shards[q].unit && shards[q].unit->isClifford() && shards[q].unit->GetTInjection()) && \
((ONE_R1_F - ProbBase(q)) <= FP_NORM_EPSILON))
Qrack::FP_NORM_EPSILON
QRACK_CONST real1 FP_NORM_EPSILON
Definition: qrack_types.hpp:268
shards
std::map< QInterface *, std::map< uintq, bitLenInt > > shards
Definition: pinvoke_api.cpp:299
ONE_R1_F
#define ONE_R1_F
Definition: qrack_types.hpp:171
CACHED_Z
#define CACHED_Z(shard)
Definition: qunit.cpp:47

◆ CACHED_PLUS

#define CACHED_PLUS (   q)
Value:
(CACHED_X(shards[q]) && !(shards[q].unit && shards[q].unit->isClifford() && shards[q].unit->GetTInjection()) && \
(ProbBase(q) <= FP_NORM_EPSILON))
CACHED_X
#define CACHED_X(shard)
Definition: qunit.cpp:45

◆ CACHED_X

#define CACHED_X (   shard)    ((shard.pauliBasis == PauliX) && !DIRTY(shard) && !QUEUED_PHASE(shard))

◆ CACHED_X_OR_Y

#define CACHED_X_OR_Y (   shard)    ((shard.pauliBasis != PauliZ) && !DIRTY(shard) && !QUEUED_PHASE(shard))

◆ CACHED_Z

#define CACHED_Z (   shard)    ((shard.pauliBasis == PauliZ) && !DIRTY(shard) && !QUEUED_PHASE(shard))

◆ CACHED_ZERO

#define CACHED_ZERO (   q)
Value:
(CACHED_Z(shards[q]) && !(shards[q].unit && shards[q].unit->isClifford() && shards[q].unit->GetTInjection()) && \
(ProbBase(q) <= FP_NORM_EPSILON))

◆ CTRL_GEN_ARGS

#define CTRL_GEN_ARGS   mappedControls, trnsMtrx, shards[target].mapped, controlPerm

◆ CTRL_I_ARGS

#define CTRL_I_ARGS   mappedControls, topRight, bottomLeft, shards[target].mapped, controlPerm

◆ CTRL_P_ARGS

#define CTRL_P_ARGS   mappedControls, topLeft, bottomRight, shards[target].mapped, controlPerm

◆ CTRL_S_ARGS

#define CTRL_S_ARGS   mappedControls, shards[qubit1].mapped, shards[qubit2].mapped

◆ CTRLED_GEN_WRAP

#define CTRLED_GEN_WRAP (   ctrld)
Value:
ApplyEitherControlled( \
controlVec, { target }, \
[&](QInterfacePtr unit, std::vector<bitLenInt> mappedControls) { \
complex trnsMtrx[4U]{ ZERO_CMPLX, ZERO_CMPLX, ZERO_CMPLX, ZERO_CMPLX }; \
if (shards[target].pauliBasis == PauliX) { \
TransformX2x2(mtrx, trnsMtrx); \
} else if (shards[target].pauliBasis == PauliY) { \
TransformY2x2(mtrx, trnsMtrx); \
} else { \
std::copy(mtrx, mtrx + 4U, trnsMtrx); \
} \
unit->ctrld; \
}, \
false, controlPerm, PayloadInfidelityFactor3(mtrx));
Qrack::QInterfacePtr
std::shared_ptr< QInterface > QInterfacePtr
Definition: qinterface.hpp:29
Qrack::PauliX
@ PauliX
Pauli X operator. Corresponds to Q# constant "PauliX.".
Definition: pauli.hpp:23
Qrack::PauliY
@ PauliY
Pauli Y operator. Corresponds to Q# constant "PauliY.".
Definition: pauli.hpp:25
Qrack::ZERO_CMPLX
QRACK_CONST complex ZERO_CMPLX
Definition: qrack_types.hpp:263
U
MICROSOFT_QUANTUM_DECL void U(_In_ uintq sid, _In_ uintq q, _In_ double theta, _In_ double phi, _In_ double lambda)
(External API) 3-parameter unitary gate
Definition: pinvoke_api.cpp:1713

◆ CTRLED_PHASE_INVERT_WRAP

#define CTRLED_PHASE_INVERT_WRAP (   ctrld,
  ctrldgen,
  isInvert,
  top,
  bottom 
)
Value:
ApplyEitherControlled( \
controlVec, { target }, \
[&](QInterfacePtr unit, std::vector<bitLenInt> mappedControls) { \
if (shards[target].pauliBasis == PauliX) { \
complex trnsMtrx[4U]{ ZERO_CMPLX, ZERO_CMPLX, ZERO_CMPLX, ZERO_CMPLX }; \
if (isInvert) { \
TransformXInvert(top, bottom, trnsMtrx); \
} else { \
TransformPhase(top, bottom, trnsMtrx); \
} \
unit->ctrldgen; \
} else if (shards[target].pauliBasis == PauliY) { \
complex trnsMtrx[4U]{ ZERO_CMPLX, ZERO_CMPLX, ZERO_CMPLX, ZERO_CMPLX }; \
if (isInvert) { \
TransformYInvert(top, bottom, trnsMtrx); \
} else { \
TransformPhase(top, bottom, trnsMtrx); \
} \
unit->ctrldgen; \
} else { \
unit->ctrld; \
} \
}, \
!isInvert, controlPerm, (isInvert ? 1.0 : 0.0) + (PhaseInfidelity(top) + PhaseInfidelity(bottom)) / 2);

◆ CTRLED_SWAP_WRAP

#define CTRLED_SWAP_WRAP (   ctrld,
  bare,
  anti 
)
Value:
ThrowIfQbIdArrayIsBad(controls, qubitCount, \
"QUnit Swap variant parameter controls array values must be within allocated qubit bounds!"); \
if (qubit1 >= qubitCount) { \
throw std::invalid_argument( \
"QUnit Swap variant qubit index parameter must be within allocated qubit bounds!"); \
} \
if (qubit2 >= qubitCount) { \
throw std::invalid_argument( \
"QUnit Swap variant qubit index parameter must be within allocated qubit bounds!"); \
} \
if (qubit1 == qubit2) { \
return; \
} \
std::vector<bitLenInt> controlVec; \
bitCapInt _perm = anti ? ZERO_BCI : (pow2(controls.size()) - ONE_BCI); \
if (TrimControls(controls, controlVec, &_perm)) { \
return; \
} \
if (controlVec.empty()) { \
bare; \
return; \
} \
ApplyEitherControlled( \
controlVec, { qubit1, qubit2 }, \
[&](QInterfacePtr unit, std::vector<bitLenInt> mappedControls) { unit->ctrld; }, false, \
anti ? ZERO_BCI : (pow2(controls.size()) - ONE_BCI), 1.0)
Qrack::ThrowIfQbIdArrayIsBad
void ThrowIfQbIdArrayIsBad(const std::vector< bitLenInt > &controls, const bitLenInt &qubitCount, std::string message)
Definition: qrack_functions.hpp:185
Qrack::pow2
bitCapInt pow2(const bitLenInt &p)
Definition: qrack_functions.hpp:143
Qrack::ONE_BCI
const bitCapInt ONE_BCI
Definition: qrack_types.hpp:137
Qrack::ZERO_BCI
const bitCapInt ZERO_BCI
Definition: qrack_types.hpp:138

◆ DIRTY

#define DIRTY (   shard)    (shard.isPhaseDirty || shard.isProbDirty)

◆ IS_1_CMPLX

#define IS_1_CMPLX (   c)    (norm(ONE_CMPLX - (c)) <= FP_NORM_EPSILON)

◆ IS_PHASE_OR_INVERT

#define IS_PHASE_OR_INVERT (   mtrx)     ((IS_NORM_0(mtrx[1U]) && IS_NORM_0(mtrx[2U])) || (IS_NORM_0(mtrx[0U]) && IS_NORM_0(mtrx[3U])))

◆ IS_SAME_UNIT

#define IS_SAME_UNIT (   shard1,
  shard2 
)    (shard1.unit && (shard1.unit == shard2.unit))

◆ QUEUED_PHASE

#define QUEUED_PHASE (   shard)
Value:
(shard.targetOfShards.size() || shard.controlsShards.size() || shard.antiTargetOfShards.size() || \
shard.antiControlsShards.size())

◆ SHARD_STATE

#define SHARD_STATE (   shard)    ((2 * norm(shard.amp0)) < ONE_R1)

◆ UNSAFE_CACHED_ONE

#define UNSAFE_CACHED_ONE (   shard)    (!shard.isProbDirty && (shard.pauliBasis == PauliZ) && IS_NORM_0(shard.amp0))

◆ UNSAFE_CACHED_X

#define UNSAFE_CACHED_X (   shard)     (!shard.isProbDirty && (shard.pauliBasis == PauliX) && (IS_NORM_0(shard.amp0) || IS_NORM_0(shard.amp1)))

◆ UNSAFE_CACHED_ZERO

#define UNSAFE_CACHED_ZERO (   shard)    (!shard.isProbDirty && (shard.pauliBasis == PauliZ) && IS_NORM_0(shard.amp1))

◆ UNSAFE_CACHED_ZERO_OR_ONE

#define UNSAFE_CACHED_ZERO_OR_ONE (   shard)     (!shard.isProbDirty && (shard.pauliBasis == PauliZ) && (IS_NORM_0(shard.amp0) || IS_NORM_0(shard.amp1)))
Generated by doxygen 1.9.1