Qrack  9.13
General classical-emulating-quantum development framework
Classes | Namespaces | Macros | Functions | Variables
wasm_api.cpp File Reference
#include "wasm_api.hpp"
#include "qcircuit.hpp"
#include "qneuron.hpp"
#include "qfactory.hpp"
#include <fstream>
#include <iostream>
#include <map>
#include <mutex>
#include <numeric>
#include <sstream>
Include dependency graph for wasm_api.cpp:

Classes

struct  Qrack::MapArithmeticResult2
 

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 META_LOCK_GUARD()   const std::lock_guard<std::mutex> metaLock(metaOperationMutex);
 
#define SIMULATOR_LOCK_GUARD(simulator)
 
#define SIMULATOR_LOCK_GUARD_VOID(sid)
 
#define SIMULATOR_LOCK_GUARD_TYPED(sid, def)
 
#define SIMULATOR_LOCK_GUARD_BOOL(sid)   SIMULATOR_LOCK_GUARD_TYPED(sid, false)
 
#define SIMULATOR_LOCK_GUARD_REAL1_F(sid)   SIMULATOR_LOCK_GUARD_TYPED(sid, ZERO_R1_F)
 
#define SIMULATOR_LOCK_GUARD_INT(sid)   SIMULATOR_LOCK_GUARD_TYPED(sid, 0U)
 
#define NEURON_LOCK_GUARD(neuron)
 
#define NEURON_LOCK_GUARD_VOID(nid)
 
#define NEURON_LOCK_GUARD_TYPED(nid, def)
 
#define NEURON_LOCK_GUARD_REAL1_F(nid)   NEURON_LOCK_GUARD_TYPED(nid, ZERO_R1_F)
 
#define NEURON_LOCK_GUARD_INT(nid)   NEURON_LOCK_GUARD_TYPED(nid, 0U)
 
#define NEURON_LOCK_GUARD_AFN(nid)   NEURON_LOCK_GUARD_TYPED(nid, QNeuronActivationFn::Sigmoid)
 
#define CIRCUIT_LOCK_GUARD(circuit)
 
#define CIRCUIT_LOCK_GUARD_TYPED(cid, def)
 
#define CIRCUIT_LOCK_GUARD_VOID(cid)
 
#define CIRCUIT_LOCK_GUARD_INT(cid)   CIRCUIT_LOCK_GUARD_TYPED(cid, 0U)
 
#define CIRCUIT_AND_SIMULATOR_LOCK_GUARD_VOID(cid, sid)
 
#define QALU(qReg)   std::dynamic_pointer_cast<QAlu>(qReg)
 
#define QPARITY(qReg)   std::dynamic_pointer_cast<QParity>(qReg)
 
#define MAP_CONTROLS_AND_LOCK(sid)
 
#define MAP_MASK_AND_LOCK(sid)
 

Functions

bitLenInt Qrack::GetSimShardId (QInterfacePtr simulator, bitLenInt i)
 
void Qrack::FillSimShards (QInterfacePtr simulator)
 
void Qrack::TransformPauliBasis (QInterfacePtr simulator, std::vector< QubitPauliBasis > qb)
 
void Qrack::RevertPauliBasis (QInterfacePtr simulator, std::vector< QubitPauliBasis > qb)
 
void Qrack::removeIdentities (std::vector< QubitPauliBasis > *qb)
 
void Qrack::RHelper (quid sid, real1_f phi, QubitPauliBasis qb)
 
void Qrack::MCRHelper (quid sid, real1_f phi, std::vector< bitLenInt > c, QubitPauliBasis qb)
 
size_t Qrack::make_mask (std::vector< QubitPauliBasis > const &qs)
 
std::map< quid, bitLenInt >::iterator Qrack::FindShardValue (bitLenInt v, std::map< quid, bitLenInt > &simMap)
 
void Qrack::SwapShardValues (bitLenInt v1, bitLenInt v2, std::map< quid, bitLenInt > &simMap)
 
bitLenInt Qrack::MapArithmetic (QInterfacePtr simulator, std::vector< bitLenInt > q)
 
MapArithmeticResult2 Qrack::MapArithmetic2 (QInterfacePtr simulator, std::vector< bitLenInt > q1, std::vector< bitLenInt > q2)
 
MapArithmeticResult2 Qrack::MapArithmetic3 (QInterfacePtr simulator, std::vector< bitLenInt > q1, std::vector< bitLenInt > q2)
 
quid Qrack::init_count_type (bitLenInt q, bool tn, bool md, bool sd, bool sh, bool bdt, bool pg, bool nw, bool hy, bool oc, bool hp)
 Options for simulator type in initialization (any set of options theoretically functions together): tn - "Tensor network" layer - JIT local circuit simplification, light-cone optimization md - "Multi-device" (TURN OFF IN SERIAL BUILDS) - distribute Schmidt-decomposed or factorized subsytems to different OpenCL devices. More...
 
quid Qrack::init ()
 "Quasi-default constructor" (for an empty simulator) More...
 
quid Qrack::init_count (bitLenInt q, bool dm)
 "Default optimal" (BQP-complete-targeted) simulator type initialization (with "direct memory" option) More...
 
quid Qrack::init_clone (quid sid)
 "Clone" simulator (no-clone theorem does not apply to classical simulation) More...
 
quid Qrack::init_clone_size (quid sid, bitLenInt n)
 
quid Qrack::init_qbdd_count (bitLenInt q)
 "Default optimal" (BQP-complete-targeted) simulator type initialization (with "direct memory" option) More...
 
void Qrack::destroy (quid sid)
 "Destroy" or release simulator allocation More...
 
void Qrack::seed (quid sid, unsigned s)
 "Seed" random number generator (if pseudo-random Mersenne twister is in use) More...
 
void Qrack::set_concurrency (quid sid, unsigned p)
 Set CPU concurrency (if build isn't serial) More...
 
void Qrack::qstabilizer_out_to_file (quid sid, std::string f)
 Output stabilizer simulation tableau to file (or raise exception for "get_error()" if incompatible simulator type) More...
 
void Qrack::qstabilizer_in_from_file (quid sid, std::string f)
 Initialize stabilizer simulation from a tableau file (or raise exception for "get_error()" if incompatible simulator type) More...
 
size_t Qrack::random_choice (quid sid, std::vector< real1 > p)
 Select from a distribution of "p.size()" count of elements according to the discrete probabilities in "p.". More...
 
void Qrack::_PhaseMask (quid sid, real1_f lambda, bitLenInt p, std::vector< bitLenInt > q, bool isParity)
 
void Qrack::PhaseParity (quid sid, real1_f lambda, std::vector< bitLenInt > q)
 Applies e^(i*angle) phase factor to all combinations of bits with odd parity, based upon permutations of qubits. More...
 
void Qrack::PhaseRootN (quid sid, bitLenInt p, std::vector< bitLenInt > q)
 Applies a -2 * PI_R1 / (2^N) phase rotation to each qubit. More...
 
real1_f Qrack::_JointEnsembleProbabilityHelper (QInterfacePtr simulator, std::vector< QubitPauliBasis > q, bool doMeasure)
 
real1_f Qrack::JointEnsembleProbability (quid sid, std::vector< QubitPauliBasis > q)
 Overall probability of any odd permutation of the masked set of bits. More...
 
void Qrack::ResetAll (quid sid)
 Set simulator to |0> permutation state. More...
 
void Qrack::allocateQubit (quid sid, bitLenInt qid)
 Allocate new qubit with ID. More...
 
bool Qrack::release (quid sid, bitLenInt q)
 Release qubit ID. More...
 
bitLenInt Qrack::num_qubits (quid sid)
 Total count of qubits in simulator instance. More...
 
void Qrack::SetPermutation (quid sid, bitCapInt p)
 Set bit string permutation eigenstate of simulator instance. More...
 
void Qrack::X (quid sid, bitLenInt q)
 (External API) "X" Gate More...
 
void Qrack::Y (quid sid, bitLenInt q)
 (External API) "Y" Gate More...
 
void Qrack::Z (quid sid, bitLenInt q)
 (External API) "Z" Gate More...
 
void Qrack::H (quid sid, bitLenInt q)
 (External API) Walsh-Hadamard transform applied for simulator ID and qubit ID More...
 
void Qrack::S (quid sid, bitLenInt q)
 (External API) "S" Gate More...
 
void Qrack::SX (quid sid, bitLenInt q)
 (External API) Square root of X gate More...
 
void Qrack::SY (quid sid, bitLenInt q)
 (External API) Square root of Y gate More...
 
void Qrack::T (quid sid, bitLenInt q)
 (External API) "T" Gate More...
 
void Qrack::AdjS (quid sid, bitLenInt q)
 (External API) Inverse "S" Gate More...
 
void Qrack::AdjSX (quid sid, bitLenInt q)
 (External API) Inverse square root of X gate More...
 
void Qrack::AdjSY (quid sid, bitLenInt q)
 (External API) Inverse square root of Y gate More...
 
void Qrack::AdjT (quid sid, bitLenInt q)
 (External API) Inverse "T" Gate More...
 
void Qrack::U (quid sid, bitLenInt q, real1_f theta, real1_f phi, real1_f lambda)
 (External API) 3-parameter unitary gate More...
 
void Qrack::Mtrx (quid sid, std::vector< complex > m, bitLenInt q)
 (External API) 2x2 complex matrix unitary gate More...
 
void Qrack::MCX (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) Controlled "X" Gate More...
 
void Qrack::MCY (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) Controlled "Y" Gate More...
 
void Qrack::MCZ (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) Controlled "Z" Gate More...
 
void Qrack::MCH (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) Controlled "H" Gate More...
 
void Qrack::MCS (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) Controlled "S" Gate More...
 
void Qrack::MCT (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) Controlled "T" Gate More...
 
void Qrack::MCAdjS (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) Controlled Inverse "S" Gate More...
 
void Qrack::MCAdjT (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) Controlled Inverse "T" Gate More...
 
void Qrack::MCU (quid sid, std::vector< bitLenInt > c, bitLenInt q, real1_f theta, real1_f phi, real1_f lambda)
 (External API) Controlled 3-parameter unitary gate More...
 
void Qrack::MCMtrx (quid sid, std::vector< bitLenInt > c, std::vector< complex > m, bitLenInt q)
 (External API) Controlled 2x2 complex matrix unitary gate More...
 
void Qrack::MACX (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) "Anti-"Controlled "X" Gate More...
 
void Qrack::MACY (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) "Anti-"Controlled "Y" Gate More...
 
void Qrack::MACZ (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) "Anti-"Controlled "Z" Gate More...
 
void Qrack::MACH (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) "Anti-"Controlled "H" Gate More...
 
void Qrack::MACS (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) "Anti-"Controlled "S" Gate More...
 
void Qrack::MACT (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) "Anti-"Controlled "T" Gate More...
 
void Qrack::MACAdjS (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) "Anti-"Controlled Inverse "S" Gate More...
 
void Qrack::MACAdjT (quid sid, std::vector< bitLenInt > c, bitLenInt q)
 (External API) "Anti-"Controlled Inverse "T" Gate More...
 
void Qrack::MACU (quid sid, std::vector< bitLenInt > c, bitLenInt q, real1_f theta, real1_f phi, real1_f lambda)
 (External API) Controlled 3-parameter unitary gate More...
 
void Qrack::MACMtrx (quid sid, std::vector< bitLenInt > c, std::vector< complex > m, bitLenInt q)
 (External API) Controlled 2x2 complex matrix unitary gate More...
 
void Qrack::UCMtrx (quid sid, std::vector< bitLenInt > c, std::vector< complex > m, bitLenInt q, bitCapIntOcl p)
 Multi-controlled gate that activates only for the specified permutation of controls, "p". More...
 
void Qrack::Multiplex1Mtrx (quid sid, std::vector< bitLenInt > c, bitLenInt q, std::vector< complex > m)
 Multi-controlled, single-target multiplexer gate. More...
 
void Qrack::MX (quid sid, std::vector< bitLenInt > q)
 (External API) Multiple "X" Gate More...
 
void Qrack::MY (quid sid, std::vector< bitLenInt > q)
 (External API) Multiple "Y" Gate More...
 
void Qrack::MZ (quid sid, std::vector< bitLenInt > q)
 (External API) Multiple "Z" Gate More...
 
void Qrack::R (quid sid, real1_f phi, QubitPauliBasis q)
 (External API) Rotation around Pauli axes More...
 
void Qrack::MCR (quid sid, real1_f phi, std::vector< bitLenInt > c, QubitPauliBasis q)
 (External API) Controlled rotation around Pauli axes More...
 
void Qrack::Exp (quid sid, real1_f phi, std::vector< QubitPauliBasis > q)
 (External API) Exponentiation of Pauli operators More...
 
void Qrack::MCExp (quid sid, real1_f phi, std::vector< bitLenInt > cs, std::vector< QubitPauliBasis > q)
 (External API) Controlled exponentiation of Pauli operators More...
 
bool Qrack::M (quid sid, bitLenInt q)
 Measure single qubit (according to Born rules) and return the result. More...
 
bool Qrack::ForceM (quid sid, bitLenInt q, bool r)
 (PSEUDO-QUANTUM:) Force measurement result of single qubit (and return the result) More...
 
bitCapInt Qrack::MAll (quid sid)
 Measure all qubits (according to Born rules) and return the result as a bit string (integer). More...
 
bool Qrack::Measure (quid sid, std::vector< QubitPauliBasis > q)
 Each in its specified Pauli basis, collapse an ensemble of qubits jointly via measurement. More...
 
std::vector< long long unsigned int > Qrack::MeasureShots (quid sid, std::vector< bitLenInt > q, unsigned s)
 Repeat (Z-basis) measurement of a set of qubits for a count of "shots" (without collapsing the simulator) More...
 
void Qrack::SWAP (quid sid, bitLenInt qi1, bitLenInt qi2)
 
void Qrack::ISWAP (quid sid, bitLenInt qi1, bitLenInt qi2)
 
void Qrack::AdjISWAP (quid sid, bitLenInt qi1, bitLenInt qi2)
 
void Qrack::FSim (quid sid, real1_f theta, real1_f phi, bitLenInt qi1, bitLenInt qi2)
 
void Qrack::CSWAP (quid sid, std::vector< bitLenInt > c, bitLenInt qi1, bitLenInt qi2)
 
void Qrack::ACSWAP (quid sid, std::vector< bitLenInt > c, bitLenInt qi1, bitLenInt qi2)
 
void Qrack::Compose (quid sid1, quid sid2, std::vector< bitLenInt > q)
 
quid Qrack::Decompose (quid sid, std::vector< bitLenInt > q)
 
void Qrack::Dispose (quid sid, std::vector< bitLenInt > q)
 
void Qrack::AND (quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo)
 
void Qrack::OR (quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo)
 
void Qrack::XOR (quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo)
 
void Qrack::NAND (quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo)
 
void Qrack::NOR (quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo)
 
void Qrack::XNOR (quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo)
 
void Qrack::CLAND (quid sid, bool ci, bitLenInt qi, bitLenInt qo)
 
void Qrack::CLOR (quid sid, bool ci, bitLenInt qi, bitLenInt qo)
 
void Qrack::CLXOR (quid sid, bool ci, bitLenInt qi, bitLenInt qo)
 
void Qrack::CLNAND (quid sid, bool ci, bitLenInt qi, bitLenInt qo)
 
void Qrack::CLNOR (quid sid, bool ci, bitLenInt qi, bitLenInt qo)
 
void Qrack::CLXNOR (quid sid, bool ci, bitLenInt qi, bitLenInt qo)
 
std::vector< real1 > Qrack::ProbAll (quid sid, std::vector< bitLenInt > q)
 Get the probabilities of all permutations of the requested subset of qubits. More...
 
real1_f Qrack::_Prob (quid sid, bitLenInt q, bool isRdm)
 
real1_f Qrack::Prob (quid sid, bitLenInt q)
 Z-basis expectation value of qubit. More...
 
real1_f Qrack::ProbRdm (quid sid, bitLenInt q)
 "Reduced density matrix" Z-basis expectation value of qubit More...
 
real1_f Qrack::_PermutationProb (quid sid, std::vector< QubitIndexState > q, bool isRdm, bool r)
 
real1_f Qrack::PermutationProb (quid sid, std::vector< QubitIndexState > q)
 Probability of specified (single) permutation of any arbitrary group of qubits. More...
 
real1_f Qrack::PermutationProbRdm (quid sid, std::vector< QubitIndexState > q, bool r)
 "Reduced density matrix" probability of specified (single) permutation of any arbitrary group of qubits More...
 
real1_f Qrack::_PermutationExpVar (quid sid, std::vector< bitLenInt > q, bool r, bool isRdm, bool isExp)
 
real1_f Qrack::PermutationExpectation (quid sid, std::vector< bitLenInt > q)
 Expectation value for bit-string integer equivalent of specified arbitrary group of qubits. More...
 
real1_f Qrack::PermutationExpectationRdm (quid sid, std::vector< bitLenInt > q, bool r)
 "Reduced density matrix" expectation value for bit-string integer equivalent of specified arbitrary group of qubits More...
 
real1_f Qrack::Variance (quid sid, std::vector< bitLenInt > q)
 Variance for bit-string integer equivalent of specified arbitrary group of qubits. More...
 
real1_f Qrack::VarianceRdm (quid sid, std::vector< bitLenInt > q, bool r)
 "Reduced density matrix" variance for bit-string integer equivalent of specified arbitrary group of qubits More...
 
real1_f Qrack::FactorizedExpVar (bool isExp, bool isRdm, quid sid, std::vector< QubitIntegerExpVar > q, bool r)
 
real1_f Qrack::FactorizedExpectation (quid sid, std::vector< QubitIntegerExpVar > q)
 Expectation value for bit-string integer from group of qubits with per-qubit integer expectation value. More...
 
real1_f Qrack::FactorizedVariance (quid sid, std::vector< QubitIntegerExpVar > q)
 Variance for bit-string integer from group of qubits with per-qubit integer variance. More...
 
real1_f Qrack::FactorizedExpectationRdm (quid sid, std::vector< QubitIntegerExpVar > q, bool r)
 "Reduced density matrix" Expectation value for bit-string integer from group of qubits with per-qubit integer expectation value More...
 
real1_f Qrack::FactorizedVarianceRdm (quid sid, std::vector< QubitIntegerExpVar > q, bool r)
 "Reduced density matrix" variance for bit-string integer from group of qubits with per-qubit integer variance More...
 
real1_f Qrack::FactorizedExpVarFp (bool isExp, bool isRdm, quid sid, std::vector< QubitRealExpVar > q, bool r)
 
real1_f Qrack::FactorizedExpectationFp (quid sid, std::vector< QubitRealExpVar > q)
 Expectation value for bit-string integer from group of qubits with per-qubit real1 expectation value. More...
 
real1_f Qrack::FactorizedVarianceFp (quid sid, std::vector< QubitRealExpVar > q)
 Variance for bit-string integer from group of qubits with per-qubit real1 variance. More...
 
real1_f Qrack::FactorizedExpectationFpRdm (quid sid, std::vector< QubitRealExpVar > q, bool r)
 "Reduced density matrix" Expectation value for bit-string integer from group of qubits with per-qubit real1 expectation value More...
 
real1_f Qrack::FactorizedVarianceFpRdm (quid sid, std::vector< QubitRealExpVar > q, bool r)
 "Reduced density matrix" variance for bit-string integer from group of qubits with per-qubit real1 variance More...
 
real1_f Qrack::UnitaryExpVar (bool isExp, quid sid, std::vector< QubitU3Basis > q)
 
real1_f Qrack::UnitaryExpectation (quid sid, std::vector< QubitU3Basis > q)
 Get the single-qubit (3-parameter) operator expectation value for the array of qubits and bases. More...
 
real1_f Qrack::UnitaryVariance (quid sid, std::vector< QubitU3Basis > q)
 Get the single-qubit (3-parameter) operator variance for the array of qubits and bases. More...
 
real1_f Qrack::MatrixExpVar (bool isExp, quid sid, std::vector< QubitMatrixBasis > q)
 
real1_f Qrack::MatrixExpectation (quid sid, std::vector< QubitMatrixBasis > q)
 Get the single-qubit (2x2) operator expectation value for the array of qubits and bases. More...
 
real1_f Qrack::MatrixVariance (quid sid, std::vector< QubitMatrixBasis > q)
 Get the single-qubit (2x2) operator variance for the array of qubits and bases. More...
 
real1_f Qrack::UnitaryExpVarEigenVal (bool isExp, quid sid, std::vector< QubitU3BasisEigenVal > q)
 
real1_f Qrack::UnitaryExpectationEigenVal (quid sid, std::vector< QubitU3BasisEigenVal > q)
 Get the single-qubit (3-parameter) operator expectation value for the array of qubits and bases. More...
 
real1_f Qrack::UnitaryVarianceEigenVal (quid sid, std::vector< QubitU3BasisEigenVal > q)
 Get the single-qubit (3-parameter) operator variance for the array of qubits and bases. More...
 
real1_f Qrack::MatrixExpVarEigenVal (bool isExp, quid sid, std::vector< QubitMatrixBasisEigenVal > q)
 
real1_f Qrack::MatrixExpectationEigenVal (quid sid, std::vector< QubitMatrixBasisEigenVal > q)
 Get the single-qubit (2x2) operator expectation value for the array of qubits and bases. More...
 
real1_f Qrack::MatrixVarianceEigenVal (quid sid, std::vector< QubitMatrixBasisEigenVal > q)
 Get the single-qubit (2x2) operator variance for the array of qubits and bases. More...
 
real1_f Qrack::PauliExpVar (bool isExp, quid sid, std::vector< QubitPauliBasis > q)
 
real1_f Qrack::PauliExpectation (quid sid, std::vector< QubitPauliBasis > q)
 Pauli operator expectation value for the array of qubits and bases. More...
 
real1_f Qrack::PauliVariance (quid sid, std::vector< QubitPauliBasis > q)
 Pauli operator variance for the array of qubits and bases. More...
 
void Qrack::QFT (quid sid, std::vector< bitLenInt > q)
 Quantum Fourier Transform. More...
 
void Qrack::IQFT (quid sid, std::vector< bitLenInt > q)
 (Inverse) Quantum Fourier Transform More...
 
void Qrack::ADD (quid sid, bitCapInt a, std::vector< bitLenInt > q)
 
void Qrack::SUB (quid sid, bitCapInt a, std::vector< bitLenInt > q)
 
void Qrack::ADDS (quid sid, bitCapInt a, bitLenInt s, std::vector< bitLenInt > q)
 
void Qrack::SUBS (quid sid, bitCapInt a, bitLenInt s, std::vector< bitLenInt > q)
 
void Qrack::MCADD (quid sid, bitCapInt a, std::vector< bitLenInt > c, std::vector< bitLenInt > q)
 
void Qrack::MCSUB (quid sid, bitCapInt a, std::vector< bitLenInt > c, std::vector< bitLenInt > q)
 
void Qrack::MUL (quid sid, bitCapInt a, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
 
void Qrack::DIV (quid sid, bitCapInt a, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
 
void Qrack::MULN (quid sid, bitCapInt a, bitCapInt m, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
 
void Qrack::DIVN (quid sid, bitCapInt a, bitCapInt m, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
 
void Qrack::POWN (quid sid, bitCapInt a, bitCapInt m, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
 
void Qrack::MCMUL (quid sid, bitCapInt a, std::vector< bitLenInt > c, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
 
void Qrack::MCDIV (quid sid, bitCapInt a, std::vector< bitLenInt > c, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
 
void Qrack::MCMULN (quid sid, bitCapInt a, std::vector< bitLenInt > c, bitCapInt m, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
 
void Qrack::MCDIVN (quid sid, bitCapInt a, std::vector< bitLenInt > c, bitCapInt m, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
 
void Qrack::MCPOWN (quid sid, bitCapInt a, std::vector< bitLenInt > c, bitCapInt m, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
 
bool Qrack::TrySeparate1Qb (quid sid, bitLenInt qi1)
 Try to factorize a single-qubit subsystem out of "bulk" simulator state. More...
 
bool Qrack::TrySeparate2Qb (quid sid, bitLenInt qi1, bitLenInt qi2)
 Try to factorize a two-qubit subsystem out of "bulk" simulator state. More...
 
bool Qrack::TrySeparateTol (quid sid, std::vector< bitLenInt > q, real1_f tol)
 Try to factorize a qubit subsystem out of "bulk" simulator state. More...
 
void Qrack::Separate (quid sid, std::vector< bitLenInt > q)
 Force (inexact) factorization of qubit subsystem out of "bulk" simulator state. More...
 
double Qrack::GetUnitaryFidelity (quid sid)
 Report fidelity for "Schmidt decomposition rounding parameter" (SDRP) and "near-Clifford rounding". More...
 
void Qrack::ResetUnitaryFidelity (quid sid)
 Reset fidelity to 1 for "Schmidt decomposition rounding parameter" (SDRP) and "near-Clifford rounding". More...
 
void Qrack::SetSdrp (quid sid, double sdrp)
 Set "Schmidt decomposition rounding parameter" (SDRP) value (see https://arxiv.org/abs/2304.14969) More...
 
void Qrack::SetNcrp (quid sid, double sdrp)
 Set "Near-Clifford rounding parameter". More...
 
void Qrack::SetReactiveSeparate (quid sid, bool irs)
 Turn off/on "reactive separation" feature (for less/more aggressive automatic state factorization) More...
 
void Qrack::SetTInjection (quid sid, bool iti)
 Turn off/on "T-injection" feature (for "near-Clifford" simulation with RZ gates) More...
 
void Qrack::SetNoiseParameter (quid sid, double np)
 Set noise parameter (for QInterfaceNoisy) More...
 
void Qrack::Normalize (quid sid)
 Normalize the state (which should never be necessary unless Decompose() is "abused") More...
 
quid Qrack::init_qneuron (quid sid, std::vector< bitLenInt > c, bitLenInt q, QNeuronActivationFn f, real1_f a, real1_f tol)
 Initialize a "quantum neuron" that takes a list of qubit "controls" for input and acts on a single "target" output qubit. More...
 
quid Qrack::clone_qneuron (quid nid)
 "Clone" a quantum neuron (which is a classical state) More...
 
void Qrack::destroy_qneuron (quid nid)
 "Destroy" or release simulator allocation More...
 
void Qrack::set_qneuron_angles (quid nid, std::vector< real1 > angles)
 Set the (RY-rotation) angle parameters for each permutation of quantum neuron input qubits. More...
 
std::vector< real1 > Qrack::get_qneuron_angles (quid nid)
 Get the (RY-rotation) angle parameters for each permutation of quantum neuron input qubits. More...
 
void Qrack::set_qneuron_alpha (quid nid, real1_f alpha)
 Set the "leakage" parameter for "leaky" quantum neuron activation functions. More...
 
real1_f Qrack::get_qneuron_alpha (quid nid)
 Get the "leakage" parameter for "leaky" quantum neuron activation functions. More...
 
void Qrack::set_qneuron_activation_fn (quid nid, QNeuronActivationFn f)
 Set the activation function for a quantum neuron. More...
 
QNeuronActivationFn Qrack::get_qneuron_activation_fn (quid nid)
 Get the activation function for a quantum neuron. More...
 
real1_f Qrack::qneuron_predict (quid nid, bool e, bool r)
 Infer quantum neuron output from inputs (after training) More...
 
real1_f Qrack::qneuron_unpredict (quid nid, bool e)
 Perform the inverse of quantum neuron inference (for "uncomputation") More...
 
real1_f Qrack::qneuron_learn_cycle (quid nid, bool e)
 Train a quantum neuron for one epoch, and also uncompute the intermediate side-effects. More...
 
void Qrack::qneuron_learn (quid nid, real1_f eta, bool e, bool r)
 Train a quantum neuron for one epoh (without uncomputing any intermediate side-effects) More...
 
void Qrack::qneuron_learn_permutation (quid nid, real1_f eta, bool e, bool r)
 Train a quantum neuron for one epoch, assuming that the input state is a Z-basis eigenstate. More...
 
quid Qrack::init_qcircuit (bool collapse, bool clifford)
 
quid Qrack::_init_qcircuit_copy (quid cid, bool isInverse, std::set< bitLenInt > q)
 
quid Qrack::init_qcircuit_clone (quid cid)
 
quid Qrack::qcircuit_inverse (quid cid)
 
quid Qrack::qcircuit_past_light_cone (quid cid, std::set< bitLenInt > q)
 
void Qrack::destroy_qcircuit (quid cid)
 
bitLenInt Qrack::get_qcircuit_qubit_count (quid cid)
 
void Qrack::qcircuit_swap (quid cid, bitLenInt q1, bitLenInt q2)
 
void Qrack::qcircuit_append_1qb (quid cid, std::vector< real1_f > m, bitLenInt q)
 
void Qrack::qcircuit_append_mc (quid cid, std::vector< real1_f > m, std::vector< bitLenInt > c, bitLenInt q, bitCapInt p)
 
void Qrack::qcircuit_run (quid cid, quid sid)
 
void Qrack::qcircuit_out_to_file (quid cid, std::string f)
 
void Qrack::qcircuit_in_from_file (quid cid, std::string f)
 
std::string Qrack::qcircuit_out_to_string (quid cid)
 

Variables

qrack_rand_gen_ptr Qrack::randNumGen = std::make_shared<qrack_rand_gen>(time(0))
 
std::mutex Qrack::metaOperationMutex
 
std::vector< QInterfacePtr > Qrack::simulators
 
std::vector< std::vector< QInterfaceEngine > > Qrack::simulatorTypes
 
std::vector< bool > Qrack::simulatorHostPointer
 
std::map< QInterface *, std::mutex > Qrack::simulatorMutexes
 
std::vector< bool > Qrack::simulatorReservations
 
std::map< QInterface *, std::map< quid, bitLenInt > > Qrack::shards
 
std::vector< int > Qrack::neuronErrors
 
std::vector< QNeuronPtr > Qrack::neurons
 
std::map< QNeuronPtr, QInterface * > Qrack::neuronSimulators
 
std::map< QNeuron *, std::mutex > Qrack::neuronMutexes
 
std::vector< bool > Qrack::neuronReservations
 
std::vector< QCircuitPtr > Qrack::circuits
 
std::map< QCircuit *, std::mutex > Qrack::circuitMutexes
 
std::vector< bool > Qrack::circuitReservations
 

Macro Definition Documentation

◆ CIRCUIT_AND_SIMULATOR_LOCK_GUARD_VOID

#define CIRCUIT_AND_SIMULATOR_LOCK_GUARD_VOID (   cid,
  sid 
)
Value:
if (sid > simulators.size()) { \
throw std::invalid_argument("Invalid argument: simulator ID not found!"); \
} \
if (cid > circuits.size()) { \
throw std::invalid_argument("Invalid argument: neuron ID not found!"); \
} \
\
QInterfacePtr simulator = simulators[sid]; \
QCircuitPtr circuit = circuits[cid]; \
std::unique_ptr<const std::lock_guard<std::mutex>> simulatorLock; \
std::unique_ptr<const std::lock_guard<std::mutex>> circuitLock; \
if (true) { \
std::lock(metaOperationMutex, simulatorMutexes[simulator.get()], circuitMutexes[circuit.get()]); \
const std::lock_guard<std::mutex> metaLock(metaOperationMutex, std::adopt_lock); \
simulatorLock = std::unique_ptr<const std::lock_guard<std::mutex>>( \
new const std::lock_guard<std::mutex>(simulatorMutexes[simulator.get()], std::adopt_lock)); \
circuitLock = std::unique_ptr<const std::lock_guard<std::mutex>>( \
new const std::lock_guard<std::mutex>(circuitMutexes[circuit.get()], std::adopt_lock)); \
} \
if (!simulator) { \
return; \
} \
if (!circuit) { \
return; \
}
std::vector< QCircuitPtr > circuits
Definition: pinvoke_api.cpp:272
std::vector< QInterfacePtr > simulators
Definition: pinvoke_api.cpp:261
std::map< QInterface *, std::mutex > simulatorMutexes
Definition: pinvoke_api.cpp:264
std::map< QCircuit *, std::mutex > circuitMutexes
Definition: pinvoke_api.cpp:273
std::mutex metaOperationMutex
Definition: pinvoke_api.cpp:258

◆ CIRCUIT_LOCK_GUARD

#define CIRCUIT_LOCK_GUARD (   circuit)
Value:
std::unique_ptr<const std::lock_guard<std::mutex>> circuitLock; \
if (true) { \
std::lock(metaOperationMutex, circuitMutexes[circuit.get()]); \
const std::lock_guard<std::mutex> metaLock(metaOperationMutex, std::adopt_lock); \
circuitLock = std::unique_ptr<const std::lock_guard<std::mutex>>( \
new const std::lock_guard<std::mutex>(circuitMutexes[circuit.get()], std::adopt_lock)); \
}

◆ CIRCUIT_LOCK_GUARD_INT

#define CIRCUIT_LOCK_GUARD_INT (   cid)    CIRCUIT_LOCK_GUARD_TYPED(cid, 0U)

◆ CIRCUIT_LOCK_GUARD_TYPED

#define CIRCUIT_LOCK_GUARD_TYPED (   cid,
  def 
)
Value:
if (cid > circuits.size()) { \
throw std::invalid_argument("Invalid argument: circuit ID not found!"); \
} \
\
QCircuitPtr circuit = circuits[cid]; \
CIRCUIT_LOCK_GUARD(circuit) \
if (!circuit) { \
return def; \
}

◆ CIRCUIT_LOCK_GUARD_VOID

#define CIRCUIT_LOCK_GUARD_VOID (   cid)
Value:
if (cid > circuits.size()) { \
throw std::invalid_argument("Invalid argument: neuron ID not found!"); \
} \
\
QCircuitPtr circuit = circuits[cid]; \
CIRCUIT_LOCK_GUARD(circuit) \
if (!circuit) { \
return; \
}

◆ MAP_CONTROLS_AND_LOCK

#define MAP_CONTROLS_AND_LOCK (   sid)
Value:
for (size_t i = 0; i < c.size(); ++i) { \
c[i] = GetSimShardId(simulator, c[i]); \
}
bitLenInt GetSimShardId(QInterfacePtr simulator, bitLenInt i)
Definition: pinvoke_api.cpp:277
#define SIMULATOR_LOCK_GUARD_VOID(sid)
Definition: wasm_api.cpp:47

◆ MAP_MASK_AND_LOCK

#define MAP_MASK_AND_LOCK (   sid)
Value:
bitCapInt mask = ZERO_BCI; \
for (size_t i = 0U; i < q.size(); ++i) { \
bi_or_ip(&mask, pow2(GetSimShardId(simulator, q[i]))); \
}
bitCapInt pow2(const bitLenInt &p)
Definition: qrack_functions.hpp:136
const bitCapInt ZERO_BCI
Definition: qrack_types.hpp:130
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:1562

◆ META_LOCK_GUARD

#define META_LOCK_GUARD ( )    const std::lock_guard<std::mutex> metaLock(metaOperationMutex);

◆ NEURON_LOCK_GUARD

#define NEURON_LOCK_GUARD (   neuron)
Value:
std::unique_ptr<const std::lock_guard<std::mutex>> neuronLock; \
std::unique_ptr<const std::lock_guard<std::mutex>> simulatorLock; \
if (true) { \
std::lock(metaOperationMutex, simulatorMutexes[neuronSimulators[neuron]], neuronMutexes[neuron.get()]); \
const std::lock_guard<std::mutex> metaLock(metaOperationMutex, std::adopt_lock); \
neuronLock = std::unique_ptr<const std::lock_guard<std::mutex>>( \
new const std::lock_guard<std::mutex>(neuronMutexes[neuron.get()], std::adopt_lock)); \
simulatorLock = std::unique_ptr<const std::lock_guard<std::mutex>>( \
new const std::lock_guard<std::mutex>(simulatorMutexes[neuronSimulators[neuron]], std::adopt_lock)); \
}
std::map< QNeuronPtr, QInterface * > neuronSimulators
Definition: pinvoke_api.cpp:269
std::map< QNeuron *, std::mutex > neuronMutexes
Definition: pinvoke_api.cpp:270

◆ NEURON_LOCK_GUARD_AFN

#define NEURON_LOCK_GUARD_AFN (   nid)    NEURON_LOCK_GUARD_TYPED(nid, QNeuronActivationFn::Sigmoid)

◆ NEURON_LOCK_GUARD_INT

#define NEURON_LOCK_GUARD_INT (   nid)    NEURON_LOCK_GUARD_TYPED(nid, 0U)

◆ NEURON_LOCK_GUARD_REAL1_F

#define NEURON_LOCK_GUARD_REAL1_F (   nid)    NEURON_LOCK_GUARD_TYPED(nid, ZERO_R1_F)

◆ NEURON_LOCK_GUARD_TYPED

#define NEURON_LOCK_GUARD_TYPED (   nid,
  def 
)
Value:
if (nid > neurons.size()) { \
throw std::invalid_argument("Invalid argument: neuron ID not found!"); \
} \
\
QNeuronPtr neuron = neurons[nid]; \
NEURON_LOCK_GUARD(neuron) \
if (!neuron) { \
return def; \
}
std::vector< QNeuronPtr > neurons
Definition: pinvoke_api.cpp:268

◆ NEURON_LOCK_GUARD_VOID

#define NEURON_LOCK_GUARD_VOID (   nid)
Value:
if (nid > neurons.size()) { \
throw std::invalid_argument("Invalid argument: neuron ID not found!"); \
} \
\
QNeuronPtr neuron = neurons[nid]; \
NEURON_LOCK_GUARD(neuron) \
if (!neuron) { \
return; \
}

◆ QALU

#define QALU (   qReg)    std::dynamic_pointer_cast<QAlu>(qReg)

◆ QPARITY

#define QPARITY (   qReg)    std::dynamic_pointer_cast<QParity>(qReg)

◆ SIMULATOR_LOCK_GUARD

#define SIMULATOR_LOCK_GUARD (   simulator)
Value:
std::unique_ptr<const std::lock_guard<std::mutex>> simulatorLock; \
if (true) { \
std::lock(metaOperationMutex, simulatorMutexes[simulator]); \
const std::lock_guard<std::mutex> metaLock(metaOperationMutex, std::adopt_lock); \
simulatorLock = std::unique_ptr<const std::lock_guard<std::mutex>>( \
new const std::lock_guard<std::mutex>(simulatorMutexes[simulator], std::adopt_lock)); \
}

◆ SIMULATOR_LOCK_GUARD_BOOL

#define SIMULATOR_LOCK_GUARD_BOOL (   sid)    SIMULATOR_LOCK_GUARD_TYPED(sid, false)

◆ SIMULATOR_LOCK_GUARD_INT

#define SIMULATOR_LOCK_GUARD_INT (   sid)    SIMULATOR_LOCK_GUARD_TYPED(sid, 0U)

◆ SIMULATOR_LOCK_GUARD_REAL1_F

#define SIMULATOR_LOCK_GUARD_REAL1_F (   sid)    SIMULATOR_LOCK_GUARD_TYPED(sid, ZERO_R1_F)

◆ SIMULATOR_LOCK_GUARD_TYPED

#define SIMULATOR_LOCK_GUARD_TYPED (   sid,
  def 
)
Value:
if (sid > simulators.size()) { \
throw std::invalid_argument("Invalid argument: simulator ID not found!"); \
} \
\
QInterfacePtr simulator = simulators[sid]; \
SIMULATOR_LOCK_GUARD(simulator.get()) \
if (!simulator) { \
return def; \
}

◆ SIMULATOR_LOCK_GUARD_VOID

#define SIMULATOR_LOCK_GUARD_VOID (   sid)
Value:
if (sid > simulators.size()) { \
throw std::invalid_argument("Invalid argument: simulator ID not found!"); \
} \
QInterfacePtr simulator = simulators[sid]; \
SIMULATOR_LOCK_GUARD(simulator.get()) \
if (!simulator) { \
return; \
}