_static/doxygen/wasm__api_8hpp_source.html

 // Copyright (c) Microsoft Corporation. All rights reserved.

 // Licensed under the MIT License.

 //

 // (Extensively modified and adapted by Daniel Strano in unitaryfund/qrack)


 #pragma once


 #include "common/pauli.hpp"

 #include "common/qneuron_activation_function.hpp"

 #include "common/qrack_types.hpp"


 #include <set>

 #include <string>

 #include <vector>


 namespace Qrack {


 typedef uint64_t quid;


 struct QubitIndexState {

     bitLenInt qid;

     bool val;

     QubitIndexState(bitLenInt q, bool v)

         : qid(q)

         , val(v)

     {

         // Intentionally left blank

     }

 };


 struct QubitIntegerExpVar {

     bitLenInt qid;

     bitCapInt val;

     QubitIntegerExpVar(bitLenInt q, bitCapInt v)

         : qid(q)

         , val(v)

     {

         // Intentionally left blank

     }

 };


 struct QubitRealExpVar {

     bitLenInt qid;

     real1_f val;

     QubitRealExpVar(bitLenInt q, real1_f v)

         : qid(q)

         , val(v)

     {

         // Intentionally left blank

     }

 };


 struct QubitPauliBasis {

     bitLenInt qid;

     Pauli b;

     QubitPauliBasis(bitLenInt q, Pauli basis)

         : qid(q)

         , b(basis)

     {

         // Intentionally left blank

     }

 };


 struct QubitU3Basis {

     bitLenInt qid;

     real1_f b[3U];

     QubitU3Basis(bitLenInt q, std::vector<real1_f> basis)

         : qid(q)

     {

         if (basis.size() != 3U) {

             throw std::invalid_argument("QubitU3Basis must have 3 basis angles!");

         }

         for (int i = 0; i < 3; ++i) {

             b[i] = basis[i];

         }

     }

 };


 struct QubitMatrixBasis {

     bitLenInt qid;

     complex b[4U];

     QubitMatrixBasis(bitLenInt q, std::vector<complex> basis)

         : qid(q)

     {

         if (basis.size() != 4U) {

             throw std::invalid_argument("QubitMatrixBasis must have 4 matrix components for basis!");

         }

         for (int i = 0; i < 4; ++i) {

             b[i] = basis[i];

         }

     }

 };


 struct QubitU3BasisEigenVal {

     bitLenInt qid;

     real1_f b[3U];

     real1_f e[2U];

     QubitU3BasisEigenVal(bitLenInt q, std::vector<real1_f> basis, std::vector<real1_f> ex)

         : qid(q)

     {

         if (basis.size() != 3U) {

             throw std::invalid_argument("QubitU3BasisEigenVal must have 3 basis angles!");

         }

         if (ex.size() != 2U) {

             throw std::invalid_argument("QubitU3BasisEigenVal must have 2 eigenvalues!");

         }

         for (int i = 0; i < 3; ++i) {

             b[i] = basis[i];

         }

         e[0U] = ex[0U];

         e[1U] = ex[1U];

     }

 };


 struct QubitMatrixBasisEigenVal {

     bitLenInt qid;

     complex b[4U];

     real1_f e[2U];

     QubitMatrixBasisEigenVal(bitLenInt q, std::vector<complex> basis, std::vector<real1_f> ex)

         : qid(q)

     {

         if (basis.size() != 4U) {

             throw std::invalid_argument("QubitMatrixBasisEigenVal must have 4 matrix components for basis!");

         }

         if (ex.size() != 2U) {

             throw std::invalid_argument("QubitMatrixBasisEigenVal must have 2 eigenvalues!");

         }

         for (int i = 0; i < 4; ++i) {

             b[i] = basis[i];

         }

         e[0U] = ex[0U];

         e[1U] = ex[1U];

     }

 };


 quid 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);


 // Utility


 quid init_count(bitLenInt q, bool dm);


 quid init_count_stabilizer(bitLenInt q);


 quid init();


 quid init_clone(quid sid);


 quid init_qbdd_count(bitLenInt q);


 void destroy(quid sid);


 void seed(quid sid, unsigned s);


 void set_concurrency(quid sid, unsigned p);


 void set_device(quid sid, int64_t did);


 void set_device_list(quid sid, std::vector<int64_t> dids);


 void allocateQubit(quid sid, bitLenInt qid);

 bool release(quid sid, bitLenInt q);

 bitLenInt num_qubits(quid sid);

 void SetPermutation(quid sid, bitCapInt p);


 void qstabilizer_out_to_file(quid sid, std::string f);

 void qstabilizer_in_from_file(quid sid, std::string f);


 std::vector<real1> ProbAll(quid sid, std::vector<bitLenInt> q);

 real1_f Prob(quid sid, bitLenInt q);

 real1_f ProbRdm(quid sid, bitLenInt q);

 real1_f PermutationProb(quid sid, std::vector<QubitIndexState> q);

 real1_f PermutationProbRdm(quid sid, std::vector<QubitIndexState> q, bool r);

 real1_f PermutationExpectation(quid sid, std::vector<bitLenInt> q);

 real1_f PermutationExpectationRdm(quid sid, std::vector<bitLenInt> q, bool r);

 real1_f FactorizedExpectation(quid sid, std::vector<QubitIntegerExpVar> q);

 real1_f FactorizedExpectationRdm(quid sid, std::vector<QubitIntegerExpVar> q, bool r);

 real1_f FactorizedExpectationFp(quid sid, std::vector<QubitRealExpVar> q);

 real1_f FactorizedExpectationFpRdm(quid sid, std::vector<QubitRealExpVar> q, bool r);

 real1_f UnitaryExpectation(quid sid, std::vector<QubitU3Basis> q);

 real1_f MatrixExpectation(quid sid, std::vector<QubitMatrixBasis> q);

 real1_f UnitaryExpectationEigenVal(quid sid, std::vector<QubitU3BasisEigenVal> q);

 real1_f MatrixExpectationEigenVal(quid sid, std::vector<QubitMatrixBasisEigenVal> q);

 real1_f PauliExpectation(quid sid, std::vector<QubitPauliBasis> q);

 real1_f Variance(quid sid, std::vector<bitLenInt> q);

 real1_f VarianceRdm(quid sid, std::vector<bitLenInt> q, bool r);

 real1_f FactorizedVariance(quid sid, std::vector<QubitIntegerExpVar> q);

 real1_f FactorizedVarianceRdm(quid sid, std::vector<QubitIntegerExpVar> q, bool r);

 real1_f FactorizedVarianceFp(quid sid, std::vector<QubitRealExpVar> q);

 real1_f FactorizedVarianceFpRdm(quid sid, std::vector<QubitRealExpVar> q, bool r);

 real1_f UnitaryVariance(quid sid, std::vector<QubitU3Basis> q);

 real1_f MatrixVariance(quid sid, std::vector<QubitMatrixBasis> q);

 real1_f UnitaryVarianceEigenVal(quid sid, std::vector<QubitU3BasisEigenVal> q);

 real1_f MatrixVarianceEigenVal(quid sid, std::vector<QubitMatrixBasisEigenVal> q);

 real1_f PauliVariance(quid sid, std::vector<QubitPauliBasis> q);


 size_t random_choice(quid sid, std::vector<real1> p);


 void PhaseParity(quid sid, real1_f lambda, std::vector<bitLenInt> q);


 void PhaseRootN(quid sid, bitLenInt p, std::vector<bitLenInt> q);


 real1_f JointEnsembleProbability(quid sid, std::vector<QubitPauliBasis> q);


 // SPAM and non-unitary


 bool M(quid sid, bitLenInt q);

 bool ForceM(quid sid, bitLenInt q, bool r);

 bool Measure(quid sid, std::vector<QubitPauliBasis> q);

 bitCapInt MAll(quid sid);

 std::vector<long long unsigned int> MeasureShots(quid sid, std::vector<bitLenInt> q, unsigned s);

 void ResetAll(quid sid);


 // single-qubit gates

 void X(quid sid, bitLenInt q);

 void Y(quid sid, bitLenInt q);

 void Z(quid sid, bitLenInt q);

 void H(quid sid, bitLenInt q);

 void S(quid sid, bitLenInt q);

 void SX(quid sid, bitLenInt q);

 void SY(quid sid, bitLenInt q);

 void T(quid sid, bitLenInt q);

 void AdjS(quid sid, bitLenInt q);

 void AdjSX(quid sid, bitLenInt q);

 void AdjSY(quid sid, bitLenInt q);

 void AdjT(quid sid, bitLenInt q);

 void U(quid sid, bitLenInt q, real1_f theta, real1_f phi, real1_f lambda);

 void Mtrx(quid sid, std::vector<complex> m, bitLenInt q);


 // multi-controlled single-qubit gates

 void MCX(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MCY(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MCZ(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MCH(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MCS(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MCT(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MCAdjS(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MCAdjT(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MCU(quid sid, std::vector<bitLenInt> c, bitLenInt q, real1_f theta, real1_f phi, real1_f lambda);

 void MCMtrx(quid sid, std::vector<bitLenInt> c, std::vector<complex> m, bitLenInt q);

 // multi-("anti"-) controlled single-qubits gates (that activate when all controls are |0>)

 void MACX(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MACY(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MACZ(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MACH(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MACS(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MACT(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MACAdjS(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MACAdjT(quid sid, std::vector<bitLenInt> c, bitLenInt q);

 void MACU(quid sid, std::vector<bitLenInt> c, bitLenInt q, real1_f theta, real1_f phi, real1_f lambda);

 void MACMtrx(quid sid, std::vector<bitLenInt> c, std::vector<complex> m, bitLenInt q);


 void UCMtrx(quid sid, std::vector<bitLenInt> c, std::vector<complex> m, bitLenInt q, bitCapIntOcl p);

 void Multiplex1Mtrx(quid sid, std::vector<bitLenInt> c, bitLenInt q, std::vector<complex> m);


 // coalesced single-qubit gates

 void MX(quid sid, std::vector<bitLenInt> q);

 void MY(quid sid, std::vector<bitLenInt> q);

 void MZ(quid sid, std::vector<bitLenInt> q);


 // single-qubit rotations

 void R(quid sid, real1_f phi, QubitPauliBasis q);

 // multi-controlled single-qubit rotations

 void MCR(quid sid, real1_f phi, std::vector<bitLenInt> c, QubitPauliBasis q);


 // exponential of Pauli operators

 void Exp(quid sid, real1_f phi, std::vector<QubitPauliBasis> q);

 // multi-controlled exponential of Pauli operators

 void MCExp(quid sid, real1_f phi, std::vector<bitLenInt> c, std::vector<QubitPauliBasis> q);


 // swap variants

 void SWAP(quid sid, bitLenInt qi1, bitLenInt qi2);

 void ISWAP(quid sid, bitLenInt qi1, bitLenInt qi2);

 void AdjISWAP(quid sid, bitLenInt qi1, bitLenInt qi2);

 void FSim(quid sid, real1_f theta, real1_f phi, bitLenInt qi1, bitLenInt qi2);

 void CSWAP(quid sid, std::vector<bitLenInt> c, bitLenInt qi1, bitLenInt qi2);

 void ACSWAP(quid sid, std::vector<bitLenInt> c, bitLenInt qi1, bitLenInt qi2);


 // Schmidt decomposition

 void Compose(quid sid1, quid sid2, std::vector<bitLenInt> q);

 quid Decompose(quid sid, std::vector<bitLenInt> q);

 void Dispose(quid sid, std::vector<bitLenInt> q);


 // Quantum boolean (Toffoli) operations:

 // Two qubits input

 void AND(quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo);

 void OR(quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo);

 void XOR(quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo);

 void NAND(quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo);

 void NOR(quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo);

 void XNOR(quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo);

 // One qubit, one classical bit input

 void CLAND(quid sid, bool ci, bitLenInt qi, bitLenInt qo);

 void CLOR(quid sid, bool ci, bitLenInt qi, bitLenInt qo);

 void CLXOR(quid sid, bool ci, bitLenInt qi, bitLenInt qo);

 void CLNAND(quid sid, bool ci, bitLenInt qi, bitLenInt qo);

 void CLNOR(quid sid, bool ci, bitLenInt qi, bitLenInt qo);

 void CLXNOR(quid sid, bool ci, bitLenInt qi, bitLenInt qo);


 void QFT(quid sid, std::vector<bitLenInt> q);

 void IQFT(quid sid, std::vector<bitLenInt> q);


 #if ENABLE_ALU

 // Arithmetic logic unit:

 // Two's complement

 void ADD(quid sid, bitCapInt a, std::vector<bitLenInt> q);

 void SUB(quid sid, bitCapInt a, std::vector<bitLenInt> q);

 // Overflow

 void ADDS(quid sid, bitCapInt a, bitLenInt s, std::vector<bitLenInt> q);

 void SUBS(quid sid, bitCapInt a, bitLenInt s, std::vector<bitLenInt> q);

 // Controlled

 void MCADD(quid sid, bitCapInt a, std::vector<bitLenInt> c, std::vector<bitLenInt> q);

 void MCSUB(quid sid, bitCapInt a, std::vector<bitLenInt> c, std::vector<bitLenInt> q);

 // In-place

 void MUL(quid sid, bitCapInt a, std::vector<bitLenInt> q, std::vector<bitLenInt> o);

 void DIV(quid sid, bitCapInt a, std::vector<bitLenInt> q, std::vector<bitLenInt> o);

 // Modulo, out-of-place

 void MULN(quid sid, bitCapInt a, bitCapInt m, std::vector<bitLenInt> q, std::vector<bitLenInt> o);

 void DIVN(quid sid, bitCapInt a, bitCapInt m, std::vector<bitLenInt> q, std::vector<bitLenInt> o);

 void POWN(quid sid, bitCapInt a, bitCapInt m, std::vector<bitLenInt> q, std::vector<bitLenInt> o);

 // Controlled in-place

 void MCMUL(quid sid, bitCapInt a, std::vector<bitLenInt> c, std::vector<bitLenInt> q, std::vector<bitLenInt> o);

 void MCDIV(quid sid, bitCapInt a, std::vector<bitLenInt> c, std::vector<bitLenInt> q, std::vector<bitLenInt> o);

 // Controlled modulo, out-of-place

 void MCMULN(

     quid sid, bitCapInt a, std::vector<bitLenInt> c, bitCapInt m, std::vector<bitLenInt> q, std::vector<bitLenInt> o);

 void MCDIVN(

     quid sid, bitCapInt a, std::vector<bitLenInt> c, bitCapInt m, std::vector<bitLenInt> q, std::vector<bitLenInt> o);

 void MCPOWN(

     quid sid, bitCapInt a, std::vector<bitLenInt> c, bitCapInt m, std::vector<bitLenInt> q, std::vector<bitLenInt> o);


 #if 0

 // Amplitude amplification

 void LDA(quid sid, std::vector<bitLenInt> qi, std::vector<bitLenInt> qv, std::vector<unsigned char> t);

 void ADC(quid sid, bitLenInt s, std::vector<bitLenInt> qi, std::vector<bitLenInt> qv, std::vector<unsigned char> t);

 void SBC(quid sid, bitLenInt s, std::vector<bitLenInt> qi, std::vector<bitLenInt> qv, std::vector<unsigned char> t);

 void Hash(quid sid, std::vector<bitLenInt> q, std::vector<unsigned char> t);

 #endif

 #endif


 // Utility functions

 bool TrySeparate1Qb(quid sid, bitLenInt qi1);

 bool TrySeparate2Qb(quid sid, bitLenInt qi1, bitLenInt qi2);

 bool TrySeparateTol(quid sid, std::vector<bitLenInt> q, real1_f tol);

 void Separate(quid sid, std::vector<bitLenInt> q);

 double GetUnitaryFidelity(quid sid);

 void ResetUnitaryFidelity(quid sid);

 void SetSdrp(quid sid, double sdrp);

 void SetNcrp(quid sid, double sdrp);

 void SetReactiveSeparate(quid sid, bool irs);

 void SetTInjection(quid sid, bool iti);

 void SetNoiseParameter(quid sid, double np);

 void Normalize(quid sid);


 quid init_qneuron(quid sid, std::vector<bitLenInt> c, bitLenInt q, QNeuronActivationFn f, real1_f a, real1_f tol);

 quid clone_qneuron(quid nid);

 void destroy_qneuron(quid nid);

 void set_qneuron_angles(quid nid, std::vector<real1> angles);

 std::vector<real1> get_qneuron_angles(quid nid);

 void set_qneuron_alpha(quid nid, real1_f alpha);

 real1_f get_qneuron_alpha(quid nid);

 void set_qneuron_activation_fn(quid nid, QNeuronActivationFn f);

 QNeuronActivationFn get_qneuron_activation_fn(quid nid);

 real1_f qneuron_predict(quid nid, bool e, bool r);

 real1_f qneuron_unpredict(quid nid, bool e);

 real1_f qneuron_learn_cycle(quid nid, bool e);

 void qneuron_learn(quid nid, real1_f eta, bool e, bool r);

 void qneuron_learn_permutation(quid nid, real1_f eta, bool e, bool r);


 // Quantum circuit objects

 quid init_qcircuit(bool collapse, bool clifford);

 quid init_qcircuit_clone(quid cid);

 quid qcircuit_inverse(quid cid);

 quid qcircuit_past_light_cone(quid cid, std::set<bitLenInt> q);

 void destroy_qcircuit(quid cid);

 bitLenInt get_qcircuit_qubit_count(quid cid);

 void qcircuit_swap(quid cid, bitLenInt q1, bitLenInt q2);

 void qcircuit_append_1qb(quid cid, std::vector<complex> m, bitLenInt q);

 void qcircuit_append_mc(quid cid, std::vector<complex> m, std::vector<bitLenInt> c, bitLenInt q, bitCapInt p);

 void qcircuit_run(quid cid, quid sid);

 void qcircuit_out_to_file(quid cid, std::string f);

 void qcircuit_in_from_file(quid cid, std::string f);

 std::string qcircuit_out_to_string(quid cid);

 } // namespace Qrack

Qrack
GLOSSARY: bitLenInt - "bit-length integer" - unsigned integer ID of qubit position in register bitCap...
Definition: complex16x2simd.hpp:25

Qrack::qneuron_learn_cycle
real1_f qneuron_learn_cycle(quid nid, bool e)
Train a quantum neuron for one epoch, and also uncompute the intermediate side-effects.
Definition: wasm_api.cpp:2674

Qrack::TrySeparate1Qb
bool TrySeparate1Qb(quid sid, bitLenInt qi1)
Try to factorize a single-qubit subsystem out of "bulk" simulator state.
Definition: wasm_api.cpp:2415

Qrack::ProbRdm
real1_f ProbRdm(quid sid, bitLenInt q)
"Reduced density matrix" Z-basis expectation value of qubit
Definition: wasm_api.cpp:1856

Qrack::set_qneuron_alpha
void set_qneuron_alpha(quid nid, real1_f alpha)
Set the "leakage" parameter for "leaky" quantum neuron activation functions.
Definition: wasm_api.cpp:2626

Qrack::MCT
void MCT(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) Controlled "T" Gate
Definition: wasm_api.cpp:1277

Qrack::CLNOR
void CLNOR(quid sid, bool ci, bitLenInt qi, bitLenInt qo)
Definition: wasm_api.cpp:1792

Qrack::X
void X(quid sid, bitLenInt q)
(External API) "X" Gate
Definition: wasm_api.cpp:1091

Qrack::qcircuit_past_light_cone
quid qcircuit_past_light_cone(quid cid, std::set< bitLenInt > q)
Definition: wasm_api.cpp:2772

Qrack::MACS
void MACS(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) "Anti-"Controlled "S" Gate
Definition: wasm_api.cpp:1367

Qrack::Y
void Y(quid sid, bitLenInt q)
(External API) "Y" Gate
Definition: wasm_api.cpp:1100

Qrack::ADD
void ADD(quid sid, bitCapInt a, std::vector< bitLenInt > q)
Definition: wasm_api.cpp:2230

Qrack::MCMULN
void MCMULN(quid sid, bitCapInt a, std::vector< bitLenInt > c, bitCapInt m, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
Definition: wasm_api.cpp:2345

Qrack::MY
void MY(quid sid, std::vector< bitLenInt > q)
(External API) Multiple "Y" Gate
Definition: wasm_api.cpp:1467

Qrack::XOR
void XOR(quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo)
Definition: wasm_api.cpp:1744

Qrack::SetPermutation
void SetPermutation(quid sid, bitCapInt p)
Set bit string permutation eigenstate of simulator instance.
Definition: wasm_api.cpp:1082

Qrack::MCADD
void MCADD(quid sid, bitCapInt a, std::vector< bitLenInt > c, std::vector< bitLenInt > q)
Definition: wasm_api.cpp:2251

Qrack::JointEnsembleProbability
real1_f JointEnsembleProbability(quid sid, std::vector< QubitPauliBasis > q)
Overall probability of any odd permutation of the masked set of bits.
Definition: wasm_api.cpp:989

Qrack::ISWAP
void ISWAP(quid sid, bitLenInt qi1, bitLenInt qi2)
Definition: wasm_api.cpp:1626

Qrack::init
quid init()
"Quasi-default constructor" (for an empty simulator)
Definition: wasm_api.cpp:634

Qrack::Compose
void Compose(quid sid1, quid sid2, std::vector< bitLenInt > q)
Definition: wasm_api.cpp:1656

Qrack::allocateQubit
void allocateQubit(quid sid, bitLenInt qid)
Allocate new qubit with ID.
Definition: wasm_api.cpp:1014

Qrack::POWN
void POWN(quid sid, bitCapInt a, bitCapInt m, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
Definition: wasm_api.cpp:2308

Qrack::MCPOWN
void MCPOWN(quid sid, bitCapInt a, std::vector< bitLenInt > c, bitCapInt m, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
Definition: wasm_api.cpp:2373

Qrack::MatrixVariance
real1_f MatrixVariance(quid sid, std::vector< QubitMatrixBasis > q)
Get the single-qubit (2x2) operator variance for the array of qubits and bases.
Definition: wasm_api.cpp:2097

Qrack::set_qneuron_angles
void set_qneuron_angles(quid nid, std::vector< real1 > angles)
Set the (RY-rotation) angle parameters for each permutation of quantum neuron input qubits.
Definition: wasm_api.cpp:2594

Qrack::qcircuit_append_1qb
void qcircuit_append_1qb(quid cid, std::vector< complex > m, bitLenInt q)

Qrack::SetNoiseParameter
void SetNoiseParameter(quid sid, double np)
Set noise parameter (for QInterfaceNoisy)
Definition: wasm_api.cpp:2491

Qrack::init_qcircuit_clone
quid init_qcircuit_clone(quid cid)
Definition: wasm_api.cpp:2768

Qrack::SetReactiveSeparate
void SetReactiveSeparate(quid sid, bool irs)
Turn off/on "reactive separation" feature (for less/more aggressive automatic state factorization)
Definition: wasm_api.cpp:2479

Qrack::get_qcircuit_qubit_count
bitLenInt get_qcircuit_qubit_count(quid cid)
Definition: wasm_api.cpp:2783

Qrack::MCH
void MCH(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) Controlled "H" Gate
Definition: wasm_api.cpp:1256

Qrack::SetSdrp
void SetSdrp(quid sid, double sdrp)
Set "Schmidt decomposition rounding parameter" (SDRP) value (see https://arxiv.org/abs/2304....
Definition: wasm_api.cpp:2467

Qrack::qcircuit_out_to_file
void qcircuit_out_to_file(quid cid, std::string f)
Definition: wasm_api.cpp:2837

Qrack::qstabilizer_out_to_file
void qstabilizer_out_to_file(quid sid, std::string f)
Output stabilizer simulation tableau to file (or raise exception for "get_error()" if incompatible si...
Definition: wasm_api.cpp:906

Qrack::SY
void SY(quid sid, bitLenInt q)
(External API) Square root of Y gate
Definition: wasm_api.cpp:1145

Qrack::MUL
void MUL(quid sid, bitCapInt a, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
Definition: wasm_api.cpp:2268

Qrack::TrySeparateTol
bool TrySeparateTol(quid sid, std::vector< bitLenInt > q, real1_f tol)
Try to factorize a qubit subsystem out of "bulk" simulator state.
Definition: wasm_api.cpp:2427

Qrack::MCX
void MCX(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) Controlled "X" Gate
Definition: wasm_api.cpp:1229

Qrack::XNOR
void XNOR(quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo)
Definition: wasm_api.cpp:1762

Qrack::MCY
void MCY(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) Controlled "Y" Gate
Definition: wasm_api.cpp:1238

Qrack::T
void T(quid sid, bitLenInt q)
(External API) "T" Gate
Definition: wasm_api.cpp:1154

Qrack::IQFT
void IQFT(quid sid, std::vector< bitLenInt > q)
(Inverse) Quantum Fourier Transform
Definition: wasm_api.cpp:2218

Qrack::MACT
void MACT(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) "Anti-"Controlled "T" Gate
Definition: wasm_api.cpp:1376

Qrack::MACU
void 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
Definition: wasm_api.cpp:1403

Qrack::MCAdjS
void MCAdjS(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) Controlled Inverse "S" Gate
Definition: wasm_api.cpp:1286

Qrack::Mtrx
void Mtrx(quid sid, std::vector< complex > m, bitLenInt q)
(External API) 2x2 complex matrix unitary gate
Definition: wasm_api.cpp:1208

Qrack::MCDIV
void MCDIV(quid sid, bitCapInt a, std::vector< bitLenInt > c, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
Definition: wasm_api.cpp:2332

Qrack::CSWAP
void CSWAP(quid sid, std::vector< bitLenInt > c, bitLenInt qi1, bitLenInt qi2)
Definition: wasm_api.cpp:1644

Qrack::Measure
bool Measure(quid sid, std::vector< QubitPauliBasis > q)
Each in its specified Pauli basis, collapse an ensemble of qubits jointly via measurement.
Definition: wasm_api.cpp:1583

Qrack::UnitaryVariance
real1_f UnitaryVariance(quid sid, std::vector< QubitU3Basis > q)
Get the single-qubit (3-parameter) operator variance for the array of qubits and bases.
Definition: wasm_api.cpp:2065

Qrack::clone_qneuron
quid clone_qneuron(quid nid)
"Clone" a quantum neuron (which is a classical state)
Definition: wasm_api.cpp:2547

Qrack::AdjISWAP
void AdjISWAP(quid sid, bitLenInt qi1, bitLenInt qi2)
Definition: wasm_api.cpp:1632

Qrack::UCMtrx
void 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,...
Definition: wasm_api.cpp:1427

Qrack::FactorizedExpectation
real1_f FactorizedExpectation(quid sid, std::vector< QubitIntegerExpVar > q)
Expectation value for bit-string integer from group of qubits with per-qubit integer expectation valu...
Definition: wasm_api.cpp:1952

Qrack::UnitaryExpectationEigenVal
real1_f UnitaryExpectationEigenVal(quid sid, std::vector< QubitU3BasisEigenVal > q)
Get the single-qubit (3-parameter) operator expectation value for the array of qubits and bases.
Definition: wasm_api.cpp:2127

Qrack::MCMUL
void MCMUL(quid sid, bitCapInt a, std::vector< bitLenInt > c, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
Definition: wasm_api.cpp:2319

Qrack::seed
void seed(quid sid, unsigned s)
"Seed" random number generator (if pseudo-random Mersenne twister is in use)
Definition: wasm_api.cpp:873

Qrack::FactorizedVariance
real1_f FactorizedVariance(quid sid, std::vector< QubitIntegerExpVar > q)
Variance for bit-string integer from group of qubits with per-qubit integer variance.
Definition: wasm_api.cpp:1960

Qrack::ACSWAP
void ACSWAP(quid sid, std::vector< bitLenInt > c, bitLenInt qi1, bitLenInt qi2)
Definition: wasm_api.cpp:1650

Qrack::MACZ
void MACZ(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) "Anti-"Controlled "Z" Gate
Definition: wasm_api.cpp:1346

Qrack::MCAdjT
void MCAdjT(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) Controlled Inverse "T" Gate
Definition: wasm_api.cpp:1295

Qrack::U
void U(quid sid, bitLenInt q, real1_f theta, real1_f phi, real1_f lambda)
(External API) 3-parameter unitary gate
Definition: wasm_api.cpp:1199

Qrack::M
bool M(quid sid, bitLenInt q)
Measure single qubit (according to Born rules) and return the result.
Definition: wasm_api.cpp:1555

Qrack::random_choice
size_t random_choice(quid sid, std::vector< real1 > p)
Select from a distribution of "p.size()" count of elements according to the discrete probabilities in...
Definition: wasm_api.cpp:940

Qrack::AdjSY
void AdjSY(quid sid, bitLenInt q)
(External API) Inverse square root of Y gate
Definition: wasm_api.cpp:1181

Qrack::CLNAND
void CLNAND(quid sid, bool ci, bitLenInt qi, bitLenInt qo)
Definition: wasm_api.cpp:1786

Qrack::complex
std::complex< real1 > complex
Definition: qrack_types.hpp:136

Qrack::FSim
void FSim(quid sid, real1_f theta, real1_f phi, bitLenInt qi1, bitLenInt qi2)
Definition: wasm_api.cpp:1638

Qrack::VarianceRdm
real1_f VarianceRdm(quid sid, std::vector< bitLenInt > q, bool r)
"Reduced density matrix" variance for bit-string integer equivalent of specified arbitrary group of q...
Definition: wasm_api.cpp:1928

Qrack::MCMtrx
void MCMtrx(quid sid, std::vector< bitLenInt > c, std::vector< complex > m, bitLenInt q)
(External API) Controlled 2x2 complex matrix unitary gate
Definition: wasm_api.cpp:1313

Qrack::PhaseParity
void 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...
Definition: wasm_api.cpp:960

Qrack::FactorizedVarianceFp
real1_f FactorizedVarianceFp(quid sid, std::vector< QubitRealExpVar > q)
Variance for bit-string integer from group of qubits with per-qubit real1 variance.
Definition: wasm_api.cpp:2013

Qrack::FactorizedExpectationFp
real1_f FactorizedExpectationFp(quid sid, std::vector< QubitRealExpVar > q)
Expectation value for bit-string integer from group of qubits with per-qubit real1 expectation value.
Definition: wasm_api.cpp:2005

Qrack::Variance
real1_f Variance(quid sid, std::vector< bitLenInt > q)
Variance for bit-string integer equivalent of specified arbitrary group of qubits.
Definition: wasm_api.cpp:1922

Qrack::qneuron_learn_permutation
void 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.
Definition: wasm_api.cpp:2697

Qrack::AdjT
void AdjT(quid sid, bitLenInt q)
(External API) Inverse "T" Gate
Definition: wasm_api.cpp:1190

Qrack::MAll
bitCapInt MAll(quid sid)
Measure all qubits (according to Born rules) and return the result as a bit string (integer).
Definition: wasm_api.cpp:1574

Qrack::Exp
void Exp(quid sid, real1_f phi, std::vector< QubitPauliBasis > q)
(External API) Exponentiation of Pauli operators
Definition: wasm_api.cpp:1503

Qrack::PermutationProb
real1_f PermutationProb(quid sid, std::vector< QubitIndexState > q)
Probability of specified (single) permutation of any arbitrary group of qubits.
Definition: wasm_api.cpp:1878

Qrack::S
void S(quid sid, bitLenInt q)
(External API) "S" Gate
Definition: wasm_api.cpp:1127

Qrack::MACX
void MACX(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) "Anti-"Controlled "X" Gate
Definition: wasm_api.cpp:1328

Qrack::destroy
void destroy(quid sid)
"Destroy" or release simulator allocation
Definition: wasm_api.cpp:860

Qrack::get_qneuron_activation_fn
QNeuronActivationFn get_qneuron_activation_fn(quid nid)
Get the activation function for a quantum neuron.
Definition: wasm_api.cpp:2644

Qrack::init_qneuron
quid 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 "t...
Definition: wasm_api.cpp:2504

Qrack::destroy_qcircuit
void destroy_qcircuit(quid cid)
Definition: wasm_api.cpp:2774

Qrack::MACH
void MACH(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) "Anti-"Controlled "H" Gate
Definition: wasm_api.cpp:1355

Qrack::set_qneuron_activation_fn
void set_qneuron_activation_fn(quid nid, QNeuronActivationFn f)
Set the activation function for a quantum neuron.
Definition: wasm_api.cpp:2638

Qrack::MatrixExpectation
real1_f MatrixExpectation(quid sid, std::vector< QubitMatrixBasis > q)
Get the single-qubit (2x2) operator expectation value for the array of qubits and bases.
Definition: wasm_api.cpp:2092

Qrack::quid
uint64_t quid
Definition: wasm_api.hpp:27

Qrack::ADDS
void ADDS(quid sid, bitCapInt a, bitLenInt s, std::vector< bitLenInt > q)
Definition: wasm_api.cpp:2240

Qrack::Separate
void Separate(quid sid, std::vector< bitLenInt > q)
Force (inexact) factorization of qubit subsystem out of "bulk" simulator state.
Definition: wasm_api.cpp:2433

Qrack::H
void H(quid sid, bitLenInt q)
(External API) Walsh-Hadamard transform applied for simulator ID and qubit ID
Definition: wasm_api.cpp:1118

Qrack::QFT
void QFT(quid sid, std::vector< bitLenInt > q)
Quantum Fourier Transform.
Definition: wasm_api.cpp:2208

Qrack::qcircuit_in_from_file
void qcircuit_in_from_file(quid cid, std::string f)
Definition: wasm_api.cpp:2847

Qrack::PhaseRootN
void PhaseRootN(quid sid, bitLenInt p, std::vector< bitLenInt > q)
Applies a -2 * PI_R1 / (2^N) phase rotation to each qubit.
Definition: wasm_api.cpp:962

Qrack::OR
void OR(quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo)
Definition: wasm_api.cpp:1738

Qrack::PauliExpectation
real1_f PauliExpectation(quid sid, std::vector< QubitPauliBasis > q)
Pauli operator expectation value for the array of qubits and bases.
Definition: wasm_api.cpp:2201

Qrack::ForceM
bool ForceM(quid sid, bitLenInt q, bool r)
(PSEUDO-QUANTUM:) Force measurement result of single qubit (and return the result)
Definition: wasm_api.cpp:1564

Qrack::SX
void SX(quid sid, bitLenInt q)
(External API) Square root of X gate
Definition: wasm_api.cpp:1136

Qrack::R
void R(quid sid, real1_f phi, QubitPauliBasis q)
(External API) Rotation around Pauli axes
Definition: wasm_api.cpp:1485

Qrack::DIV
void DIV(quid sid, bitCapInt a, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
Definition: wasm_api.cpp:2278

Qrack::MACAdjT
void MACAdjT(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) "Anti-"Controlled Inverse "T" Gate
Definition: wasm_api.cpp:1394

Qrack::MCDIVN
void MCDIVN(quid sid, bitCapInt a, std::vector< bitLenInt > c, bitCapInt m, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
Definition: wasm_api.cpp:2359

Qrack::qcircuit_swap
void qcircuit_swap(quid cid, bitLenInt q1, bitLenInt q2)
Definition: wasm_api.cpp:2788

Qrack::UnitaryVarianceEigenVal
real1_f UnitaryVarianceEigenVal(quid sid, std::vector< QubitU3BasisEigenVal > q)
Get the single-qubit (3-parameter) operator variance for the array of qubits and bases.
Definition: wasm_api.cpp:2135

Qrack::CLOR
void CLOR(quid sid, bool ci, bitLenInt qi, bitLenInt qo)
Definition: wasm_api.cpp:1774

Qrack::PermutationExpectationRdm
real1_f PermutationExpectationRdm(quid sid, std::vector< bitLenInt > q, bool r)
"Reduced density matrix" expectation value for bit-string integer equivalent of specified arbitrary g...
Definition: wasm_api.cpp:1914

Qrack::num_qubits
bitLenInt num_qubits(quid sid)
Total count of qubits in simulator instance.
Definition: wasm_api.cpp:1076

Qrack::init_count_stabilizer
quid init_count_stabilizer(bitLenInt q)
Initialize a simulator ID with "q" qubits as purely a stabilizer simulator.
Definition: wasm_api.cpp:684

Qrack::CLXOR
void CLXOR(quid sid, bool ci, bitLenInt qi, bitLenInt qo)
Definition: wasm_api.cpp:1780

Qrack::PermutationProbRdm
real1_f PermutationProbRdm(quid sid, std::vector< QubitIndexState > q, bool r)
"Reduced density matrix" probability of specified (single) permutation of any arbitrary group of qubi...
Definition: wasm_api.cpp:1884

Qrack::MCSUB
void MCSUB(quid sid, bitCapInt a, std::vector< bitLenInt > c, std::vector< bitLenInt > q)
Definition: wasm_api.cpp:2259

Qrack::qstabilizer_in_from_file
void qstabilizer_in_from_file(quid sid, std::string f)
Initialize stabilizer simulation from a tableau file (or raise exception for "get_error()" if incompa...
Definition: wasm_api.cpp:920

Qrack::AdjSX
void AdjSX(quid sid, bitLenInt q)
(External API) Inverse square root of X gate
Definition: wasm_api.cpp:1172

Qrack::MZ
void MZ(quid sid, std::vector< bitLenInt > q)
(External API) Multiple "Z" Gate
Definition: wasm_api.cpp:1476

Qrack::MULN
void MULN(quid sid, bitCapInt a, bitCapInt m, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
Definition: wasm_api.cpp:2288

Qrack::Prob
real1_f Prob(quid sid, bitLenInt q)
Z-basis expectation value of qubit.
Definition: wasm_api.cpp:1850

Qrack::destroy_qneuron
void destroy_qneuron(quid nid)
"Destroy" or release simulator allocation
Definition: wasm_api.cpp:2584

Qrack::FactorizedExpectationRdm
real1_f 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...
Definition: wasm_api.cpp:1969

Qrack::get_qneuron_alpha
real1_f get_qneuron_alpha(quid nid)
Get the "leakage" parameter for "leaky" quantum neuron activation functions.
Definition: wasm_api.cpp:2632

Qrack::SetTInjection
void SetTInjection(quid sid, bool iti)
Turn off/on "T-injection" feature (for "near-Clifford" simulation with RZ gates)
Definition: wasm_api.cpp:2485

Qrack::real1_f
float real1_f
Definition: qrack_types.hpp:103

Qrack::qneuron_learn
void qneuron_learn(quid nid, real1_f eta, bool e, bool r)
Train a quantum neuron for one epoh (without uncomputing any intermediate side-effects)
Definition: wasm_api.cpp:2686

Qrack::Decompose
quid Decompose(quid sid, std::vector< bitLenInt > q)
Definition: wasm_api.cpp:1686

Qrack::Dispose
void Dispose(quid sid, std::vector< bitLenInt > q)
Definition: wasm_api.cpp:1712

Qrack::CLAND
void CLAND(quid sid, bool ci, bitLenInt qi, bitLenInt qo)
Definition: wasm_api.cpp:1768

Qrack::qcircuit_out_to_string
std::string qcircuit_out_to_string(quid cid)
Definition: wasm_api.cpp:2857

Qrack::init_qcircuit
quid init_qcircuit(bool collapse, bool clifford)
Definition: wasm_api.cpp:2708

Qrack::qcircuit_inverse
quid qcircuit_inverse(quid cid)
Definition: wasm_api.cpp:2770

Qrack::qcircuit_append_mc
void qcircuit_append_mc(quid cid, std::vector< complex > m, std::vector< bitLenInt > c, bitLenInt q, bitCapInt p)

Qrack::NAND
void NAND(quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo)
Definition: wasm_api.cpp:1750

Qrack::qneuron_unpredict
real1_f qneuron_unpredict(quid nid, bool e)
Perform the inverse of quantum neuron inference (for "uncomputation")
Definition: wasm_api.cpp:2662

Qrack::SetNcrp
void SetNcrp(quid sid, double sdrp)
Set "Near-Clifford rounding parameter".
Definition: wasm_api.cpp:2473

Qrack::set_concurrency
void set_concurrency(quid sid, unsigned p)
Set CPU concurrency (if build isn't serial)
Definition: wasm_api.cpp:882

Qrack::set_device_list
void set_device_list(quid sid, std::vector< int64_t > dids)
Set GPU device IDs on the simulator (if the simulator is GPU-accelerated)
Definition: wasm_api.cpp:900

Qrack::TrySeparate2Qb
bool TrySeparate2Qb(quid sid, bitLenInt qi1, bitLenInt qi2)
Try to factorize a two-qubit subsystem out of "bulk" simulator state.
Definition: wasm_api.cpp:2421

Qrack::GetUnitaryFidelity
double GetUnitaryFidelity(quid sid)
Report fidelity for "Schmidt decomposition rounding parameter" (SDRP) and "near-Clifford rounding".
Definition: wasm_api.cpp:2455

Qrack::ResetUnitaryFidelity
void ResetUnitaryFidelity(quid sid)
Reset fidelity to 1 for "Schmidt decomposition rounding parameter" (SDRP) and "near-Clifford rounding...
Definition: wasm_api.cpp:2461

Qrack::ResetAll
void ResetAll(quid sid)
Set simulator to |0> permutation state.
Definition: wasm_api.cpp:1005

Qrack::MACAdjS
void MACAdjS(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) "Anti-"Controlled Inverse "S" Gate
Definition: wasm_api.cpp:1385

Qrack::DIVN
void DIVN(quid sid, bitCapInt a, bitCapInt m, std::vector< bitLenInt > q, std::vector< bitLenInt > o)
Definition: wasm_api.cpp:2298

Qrack::get_qneuron_angles
std::vector< real1 > get_qneuron_angles(quid nid)
Get the (RY-rotation) angle parameters for each permutation of quantum neuron input qubits.
Definition: wasm_api.cpp:2606

Qrack::qneuron_predict
real1_f qneuron_predict(quid nid, bool e, bool r)
Infer quantum neuron output from inputs (after training)
Definition: wasm_api.cpp:2650

Qrack::CLXNOR
void CLXNOR(quid sid, bool ci, bitLenInt qi, bitLenInt qo)
Definition: wasm_api.cpp:1798

Qrack::SWAP
void SWAP(quid sid, bitLenInt qi1, bitLenInt qi2)
Definition: wasm_api.cpp:1620

Qrack::NOR
void NOR(quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo)
Definition: wasm_api.cpp:1756

Qrack::SUBS
void SUBS(quid sid, bitCapInt a, bitLenInt s, std::vector< bitLenInt > q)
Definition: wasm_api.cpp:2245

Qrack::MeasureShots
std::vector< long long unsigned int > 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 simula...
Definition: wasm_api.cpp:1594

Qrack::init_count
quid init_count(bitLenInt q, bool dm)
"Default optimal" (BQP-complete-targeted) simulator type initialization (with "direct memory" option)
Definition: wasm_api.cpp:639

Qrack::AND
void AND(quid sid, bitLenInt qi1, bitLenInt qi2, bitLenInt qo)
Definition: wasm_api.cpp:1732

Qrack::PauliVariance
real1_f PauliVariance(quid sid, std::vector< QubitPauliBasis > q)
Pauli operator variance for the array of qubits and bases.
Definition: wasm_api.cpp:2206

Qrack::PermutationExpectation
real1_f PermutationExpectation(quid sid, std::vector< bitLenInt > q)
Expectation value for bit-string integer equivalent of specified arbitrary group of qubits.
Definition: wasm_api.cpp:1905

Qrack::MCU
void 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
Definition: wasm_api.cpp:1304

Qrack::Normalize
void Normalize(quid sid)
Normalize the state (which should never be necessary unless Decompose() is "abused")
Definition: wasm_api.cpp:2497

Qrack::AdjS
void AdjS(quid sid, bitLenInt q)
(External API) Inverse "S" Gate
Definition: wasm_api.cpp:1163

Qrack::MACY
void MACY(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) "Anti-"Controlled "Y" Gate
Definition: wasm_api.cpp:1337

Qrack::Pauli
Pauli
Enumerated list of Pauli bases.
Definition: pauli.hpp:19

Qrack::ProbAll
std::vector< real1 > ProbAll(quid sid, std::vector< bitLenInt > q)
Get the probabilities of all permutations of the requested subset of qubits.
Definition: wasm_api.cpp:1804

Qrack::FactorizedVarianceFpRdm
real1_f 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 va...
Definition: wasm_api.cpp:2031

Qrack::SUB
void SUB(quid sid, bitCapInt a, std::vector< bitLenInt > q)
Definition: wasm_api.cpp:2235

Qrack::FactorizedExpectationFpRdm
real1_f 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...
Definition: wasm_api.cpp:2022

Qrack::qcircuit_run
void qcircuit_run(quid cid, quid sid)
Definition: wasm_api.cpp:2831

Qrack::MCR
void MCR(quid sid, real1_f phi, std::vector< bitLenInt > c, QubitPauliBasis q)
(External API) Controlled rotation around Pauli axes
Definition: wasm_api.cpp:1494

Qrack::MCExp
void MCExp(quid sid, real1_f phi, std::vector< bitLenInt > c, std::vector< QubitPauliBasis > q)
(External API) Controlled exponentiation of Pauli operators
Definition: wasm_api.cpp:1529

Qrack::Z
void Z(quid sid, bitLenInt q)
(External API) "Z" Gate
Definition: wasm_api.cpp:1109

Qrack::UnitaryExpectation
real1_f UnitaryExpectation(quid sid, std::vector< QubitU3Basis > q)
Get the single-qubit (3-parameter) operator expectation value for the array of qubits and bases.
Definition: wasm_api.cpp:2060

Qrack::QNeuronActivationFn
QNeuronActivationFn
Enumerated list of activation functions.
Definition: qneuron_activation_function.hpp:19

Qrack::FactorizedVarianceRdm
real1_f 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 ...
Definition: wasm_api.cpp:1978

Qrack::Multiplex1Mtrx
void Multiplex1Mtrx(quid sid, std::vector< bitLenInt > c, bitLenInt q, std::vector< complex > m)
Multi-controlled, single-target multiplexer gate.
Definition: wasm_api.cpp:1439

Qrack::init_count_type
quid 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): t...
Definition: wasm_api.cpp:549

Qrack::init_qbdd_count
quid init_qbdd_count(bitLenInt q)
"Default optimal" (BQP-complete-targeted) simulator type initialization (with "direct memory" option)
Definition: wasm_api.cpp:814

Qrack::MX
void MX(quid sid, std::vector< bitLenInt > q)
(External API) Multiple "X" Gate
Definition: wasm_api.cpp:1458

Qrack::set_device
void set_device(quid sid, int64_t did)
Set GPU device ID on the simulator (if the simulator is GPU-accelerated)
Definition: wasm_api.cpp:891

Qrack::MACMtrx
void MACMtrx(quid sid, std::vector< bitLenInt > c, std::vector< complex > m, bitLenInt q)
(External API) Controlled 2x2 complex matrix unitary gate
Definition: wasm_api.cpp:1412

Qrack::init_clone
quid init_clone(quid sid)
"Clone" simulator (no-clone theorem does not apply to classical simulation)
Definition: wasm_api.cpp:730

Qrack::MCS
void MCS(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) Controlled "S" Gate
Definition: wasm_api.cpp:1268

Qrack::MatrixExpectationEigenVal
real1_f MatrixExpectationEigenVal(quid sid, std::vector< QubitMatrixBasisEigenVal > q)
Get the single-qubit (2x2) operator expectation value for the array of qubits and bases.
Definition: wasm_api.cpp:2169

Qrack::MCZ
void MCZ(quid sid, std::vector< bitLenInt > c, bitLenInt q)
(External API) Controlled "Z" Gate
Definition: wasm_api.cpp:1247

Qrack::MatrixVarianceEigenVal
real1_f MatrixVarianceEigenVal(quid sid, std::vector< QubitMatrixBasisEigenVal > q)
Get the single-qubit (2x2) operator variance for the array of qubits and bases.
Definition: wasm_api.cpp:2177

Qrack::release
bool release(quid sid, bitLenInt q)
Release qubit ID.
Definition: wasm_api.cpp:1044

pauli.hpp

SBC
MICROSOFT_QUANTUM_DECL void SBC(_In_ uintq sid, uintq s, _In_ uintq ni, _In_reads_(ni) uintq *qi, _In_ uintq nv, _In_reads_(nv) uintq *qv, unsigned char *t)
Definition: pinvoke_api.cpp:3502

Hash
MICROSOFT_QUANTUM_DECL void Hash(_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, unsigned char *t)
Definition: pinvoke_api.cpp:3514

ADC
MICROSOFT_QUANTUM_DECL void ADC(_In_ uintq sid, uintq s, _In_ uintq ni, _In_reads_(ni) uintq *qi, _In_ uintq nv, _In_reads_(nv) uintq *qv, unsigned char *t)
Definition: pinvoke_api.cpp:3490

LDA
MICROSOFT_QUANTUM_DECL void LDA(_In_ uintq sid, _In_ uintq ni, _In_reads_(ni) uintq *qi, _In_ uintq nv, _In_reads_(nv) uintq *qv, unsigned char *t)
Definition: pinvoke_api.cpp:3478

qneuron_activation_function.hpp

qrack_types.hpp

bitLenInt
#define bitLenInt
Definition: qrack_types.hpp:42

bitCapInt
#define bitCapInt
Definition: qrack_types.hpp:66

bitCapIntOcl
#define bitCapIntOcl
Definition: qrack_types.hpp:54

Qrack::QubitIndexState
Definition: wasm_api.hpp:29

Qrack::QubitIndexState::QubitIndexState
QubitIndexState(bitLenInt q, bool v)
Definition: wasm_api.hpp:32

Qrack::QubitIndexState::val
bool val
Definition: wasm_api.hpp:31

Qrack::QubitIndexState::qid
bitLenInt qid
Definition: wasm_api.hpp:30

Qrack::QubitIntegerExpVar
Definition: wasm_api.hpp:40

Qrack::QubitIntegerExpVar::QubitIntegerExpVar
QubitIntegerExpVar(bitLenInt q, bitCapInt v)
Definition: wasm_api.hpp:43

Qrack::QubitIntegerExpVar::qid
bitLenInt qid
Definition: wasm_api.hpp:41

Qrack::QubitIntegerExpVar::val
bitCapInt val
Definition: wasm_api.hpp:42

Qrack::QubitMatrixBasisEigenVal
Definition: wasm_api.hpp:124

Qrack::QubitMatrixBasisEigenVal::b
complex b[4U]
Definition: wasm_api.hpp:126

Qrack::QubitMatrixBasisEigenVal::e
real1_f e[2U]
Definition: wasm_api.hpp:127

Qrack::QubitMatrixBasisEigenVal::qid
bitLenInt qid
Definition: wasm_api.hpp:125

Qrack::QubitMatrixBasisEigenVal::QubitMatrixBasisEigenVal
QubitMatrixBasisEigenVal(bitLenInt q, std::vector< complex > basis, std::vector< real1_f > ex)
Definition: wasm_api.hpp:128

Qrack::QubitMatrixBasis
Definition: wasm_api.hpp:88

Qrack::QubitMatrixBasis::b
complex b[4U]
Definition: wasm_api.hpp:90

Qrack::QubitMatrixBasis::QubitMatrixBasis
QubitMatrixBasis(bitLenInt q, std::vector< complex > basis)
Definition: wasm_api.hpp:91

Qrack::QubitMatrixBasis::qid
bitLenInt qid
Definition: wasm_api.hpp:89

Qrack::QubitPauliBasis
Definition: wasm_api.hpp:62

Qrack::QubitPauliBasis::b
Pauli b
Definition: wasm_api.hpp:64

Qrack::QubitPauliBasis::QubitPauliBasis
QubitPauliBasis(bitLenInt q, Pauli basis)
Definition: wasm_api.hpp:65

Qrack::QubitPauliBasis::qid
bitLenInt qid
Definition: wasm_api.hpp:63

Qrack::QubitRealExpVar
Definition: wasm_api.hpp:51

Qrack::QubitRealExpVar::QubitRealExpVar
QubitRealExpVar(bitLenInt q, real1_f v)
Definition: wasm_api.hpp:54

Qrack::QubitRealExpVar::qid
bitLenInt qid
Definition: wasm_api.hpp:52

Qrack::QubitRealExpVar::val
real1_f val
Definition: wasm_api.hpp:53

Qrack::QubitU3BasisEigenVal
Definition: wasm_api.hpp:103

Qrack::QubitU3BasisEigenVal::qid
bitLenInt qid
Definition: wasm_api.hpp:104

Qrack::QubitU3BasisEigenVal::QubitU3BasisEigenVal
QubitU3BasisEigenVal(bitLenInt q, std::vector< real1_f > basis, std::vector< real1_f > ex)
Definition: wasm_api.hpp:107

Qrack::QubitU3BasisEigenVal::e
real1_f e[2U]
Definition: wasm_api.hpp:106

Qrack::QubitU3BasisEigenVal::b
real1_f b[3U]
Definition: wasm_api.hpp:105

Qrack::QubitU3Basis
Definition: wasm_api.hpp:73

Qrack::QubitU3Basis::qid
bitLenInt qid
Definition: wasm_api.hpp:74

Qrack::QubitU3Basis::b
real1_f b[3U]
Definition: wasm_api.hpp:75

Qrack::QubitU3Basis::QubitU3Basis
QubitU3Basis(bitLenInt q, std::vector< real1_f > basis)
Definition: wasm_api.hpp:76