#include "pinvoke_api.hpp"
#include "qcircuit.hpp"
#include "qneuron.hpp"
#include "qfactory.hpp"
#include <fstream>
#include <iostream>
#include <map>
#include <mutex>

Include dependency graph for pinvoke_api.cpp:

Classes
struct	MapArithmeticResult2

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_DOUBLE(sid) SIMULATOR_LOCK_GUARD_TYPED(sid, 0.0)

#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_DOUBLE(nid) NEURON_LOCK_GUARD_TYPED(nid, 0.0)

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

#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, numC)

#define	MAP_MASK_AND_LOCK(sid, numQ)

Functions
bitLenInt	MaxShardQubits ()

void	TransformPauliBasis (QInterfacePtr simulator, uintq len, int bases, uintq qubitIds)

void	RevertPauliBasis (QInterfacePtr simulator, uintq len, int bases, uintq qubitIds)

void	removeIdentities (std::vector< int > b, std::vector< bitLenInt > qs)

void	RHelper (uintq sid, uintq b, double phi, uintq q)

void	MCRHelper (uintq sid, uintq b, double phi, uintq n, uintq *c, uintq q)

std::size_t	make_mask (std::vector< bitLenInt > const &qs)

std::map< uintq, bitLenInt >::iterator	FindShardValue (bitLenInt v, std::map< uintq, bitLenInt > &simMap)

void	SwapShardValues (bitLenInt v1, bitLenInt v2, std::map< uintq, bitLenInt > &simMap)

uintq	MapArithmetic (QInterfacePtr simulator, uintq n, uintq *q)

MapArithmeticResult2	MapArithmetic2 (QInterfacePtr simulator, uintq n, uintq q1, uintq q2)

MapArithmeticResult2	MapArithmetic3 (QInterfacePtr simulator, uintq n1, uintq q1, uintq n2, uintq q2)

void	_darray_to_creal1_array (double params, bitCapIntOcl componentCount, complex amps)

bitCapInt	_combineA (uintq na, const uintq *a)

MICROSOFT_QUANTUM_DECL int	get_error (_In_ uintq sid)
	(External API) Poll after each operation to check whether error occurred. More...

MICROSOFT_QUANTUM_DECL uintq	init_count_type (_In_ uintq q, _In_ bool tn, _In_ bool md, _In_ bool sd, _In_ bool sh, _In_ bool bdt, _In_ bool pg, _In_ bool zxf, _In_ bool hy, _In_ bool oc, _In_ bool hp)
	(External API) Initialize a simulator ID with "q" qubits and explicit layer options on/off More...

MICROSOFT_QUANTUM_DECL uintq	init_count (_In_ uintq q, _In_ bool hp)
	(External API) Initialize a simulator ID with "q" qubits and implicit default layer options. More...

MICROSOFT_QUANTUM_DECL uintq	init_count_pager (_In_ uintq q, _In_ bool hp)
	(External API) Initialize a simulator ID with "q" qubits and implicit default layer options. More...

MICROSOFT_QUANTUM_DECL uintq	init_clone (_In_ uintq sid)
	(External API) Initialize a simulator ID that clones simulator ID "sid" More...

MICROSOFT_QUANTUM_DECL void	destroy (_In_ uintq sid)
	(External API) Destroy a simulator (ID will not be reused) More...

MICROSOFT_QUANTUM_DECL void	seed (_In_ uintq sid, _In_ uintq s)
	(External API) Set RNG seed for simulator ID More...

MICROSOFT_QUANTUM_DECL void	set_concurrency (_In_ uintq sid, _In_ uintq p)
	(External API) Set concurrency level per QEngine shard More...

MICROSOFT_QUANTUM_DECL void	qstabilizer_out_to_file (_In_ uintq sid, _In_ char *f)

MICROSOFT_QUANTUM_DECL void	qstabilizer_in_from_file (_In_ uintq sid, _In_ char *f)

MICROSOFT_QUANTUM_DECL void	DumpIds (_In_ uintq sid, _In_ IdCallback callback)
	(External API) "Dump" all IDs from the selected simulator ID into the callback More...

MICROSOFT_QUANTUM_DECL void	Dump (_In_ uintq sid, _In_ ProbAmpCallback callback)
	(External API) "Dump" state vector from the selected simulator ID into the callback More...

MICROSOFT_QUANTUM_DECL void	InKet (_In_ uintq sid, _In_ real1_f *ket)
	(External API) Set state vector for the selected simulator ID. More...

MICROSOFT_QUANTUM_DECL void	OutKet (_In_ uintq sid, _In_ real1_f *ket)
	(External API) Set state vector for the selected simulator ID. More...

MICROSOFT_QUANTUM_DECL std::size_t	random_choice (_In_ uintq sid, _In_ std::size_t n, _In_reads_(n) double *p)
	(External API) Select from a distribution of "n" elements according the discrete probabilities in "d." More...

MICROSOFT_QUANTUM_DECL void	PhaseParity (_In_ uintq sid, _In_ double lambda, _In_ uintq n, _In_reads_(n) uintq *q)

double	_JointEnsembleProbabilityHelper (QInterfacePtr simulator, uintq n, int b, uintq q, bool doMeasure)

MICROSOFT_QUANTUM_DECL double	JointEnsembleProbability (_In_ uintq sid, _In_ uintq n, _In_reads_(n) int b, _In_reads_(n) uintq q)
	(External API) Find the joint probability for all specified qubits under the respective Pauli basis transformations. More...

MICROSOFT_QUANTUM_DECL void	ResetAll (_In_ uintq sid)
	(External API) Set the simulator to a computational basis permutation. More...

MICROSOFT_QUANTUM_DECL void	allocateQubit (_In_ uintq sid, _In_ uintq qid)
	(External API) Allocate 1 new qubit with the given qubit ID, under the simulator ID More...

MICROSOFT_QUANTUM_DECL bool	release (_In_ uintq sid, _In_ uintq q)
	(External API) Release 1 qubit with the given qubit ID, under the simulator ID More...

MICROSOFT_QUANTUM_DECL uintq	num_qubits (_In_ uintq sid)

MICROSOFT_QUANTUM_DECL void	X (_In_ uintq sid, _In_ uintq q)
	(External API) "X" Gate More...

MICROSOFT_QUANTUM_DECL void	Y (_In_ uintq sid, _In_ uintq q)
	(External API) "Y" Gate More...

MICROSOFT_QUANTUM_DECL void	Z (_In_ uintq sid, _In_ uintq q)
	(External API) "Z" Gate More...

MICROSOFT_QUANTUM_DECL void	H (_In_ uintq sid, _In_ uintq q)
	(External API) Walsh-Hadamard transform applied for simulator ID and qubit ID More...

MICROSOFT_QUANTUM_DECL void	S (_In_ uintq sid, _In_ uintq q)
	(External API) "S" Gate More...

MICROSOFT_QUANTUM_DECL void	T (_In_ uintq sid, _In_ uintq q)
	(External API) "T" Gate More...

MICROSOFT_QUANTUM_DECL void	AdjS (_In_ uintq sid, _In_ uintq q)
	(External API) Inverse "S" Gate More...

MICROSOFT_QUANTUM_DECL void	AdjT (_In_ uintq sid, _In_ uintq q)
	(External API) Inverse "T" Gate More...

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 More...

MICROSOFT_QUANTUM_DECL void	Mtrx (_In_ uintq sid, _In_reads_(8) double *m, _In_ uintq q)
	(External API) 2x2 complex matrix unitary gate More...

MICROSOFT_QUANTUM_DECL void	MCX (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) Controlled "X" Gate More...

MICROSOFT_QUANTUM_DECL void	MCY (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) Controlled "Y" Gate More...

MICROSOFT_QUANTUM_DECL void	MCZ (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) Controlled "Z" Gate More...

MICROSOFT_QUANTUM_DECL void	MCH (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) Controlled "H" Gate More...

MICROSOFT_QUANTUM_DECL void	MCS (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) Controlled "S" Gate More...

MICROSOFT_QUANTUM_DECL void	MCT (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) Controlled "T" Gate More...

MICROSOFT_QUANTUM_DECL void	MCAdjS (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) Controlled Inverse "S" Gate More...

MICROSOFT_QUANTUM_DECL void	MCAdjT (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) Controlled Inverse "T" Gate More...

MICROSOFT_QUANTUM_DECL void	MCU (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q, _In_ double theta, _In_ double phi, _In_ double lambda)
	(External API) Controlled 3-parameter unitary gate More...

MICROSOFT_QUANTUM_DECL void	MCMtrx (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq c, _In_reads_(8) double m, _In_ uintq q)
	(External API) Controlled 2x2 complex matrix unitary gate More...

MICROSOFT_QUANTUM_DECL void	MACX (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) "Anti-"Controlled "X" Gate More...

MICROSOFT_QUANTUM_DECL void	MACY (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) "Anti-"Controlled "Y" Gate More...

MICROSOFT_QUANTUM_DECL void	MACZ (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) "Anti-"Controlled "Z" Gate More...

MICROSOFT_QUANTUM_DECL void	MACH (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) "Anti-"Controlled "H" Gate More...

MICROSOFT_QUANTUM_DECL void	MACS (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) "Anti-"Controlled "S" Gate More...

MICROSOFT_QUANTUM_DECL void	MACT (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) "Anti-"Controlled "T" Gate More...

MICROSOFT_QUANTUM_DECL void	MACAdjS (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) "Anti-"Controlled Inverse "S" Gate More...

MICROSOFT_QUANTUM_DECL void	MACAdjT (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) "Anti-"Controlled Inverse "T" Gate More...

MICROSOFT_QUANTUM_DECL void	MACU (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q, _In_ double theta, _In_ double phi, _In_ double lambda)
	(External API) Controlled 3-parameter unitary gate More...

MICROSOFT_QUANTUM_DECL void	MACMtrx (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq c, _In_reads_(8) double m, _In_ uintq q)
	(External API) Controlled 2x2 complex matrix unitary gate More...

MICROSOFT_QUANTUM_DECL void	UCMtrx (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq c, _In_reads_(8) double m, _In_ uintq q, _In_ uintq p)
	(External API) Controlled 2x2 complex matrix unitary gate with arbitrary control permutation More...

MICROSOFT_QUANTUM_DECL void	Multiplex1Mtrx (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq c, _In_ uintq q, double m)

MICROSOFT_QUANTUM_DECL void	MX (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q)
	(External API) Multiple "X" Gate More...

MICROSOFT_QUANTUM_DECL void	MY (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q)
	(External API) Multiple "Y" Gate More...

MICROSOFT_QUANTUM_DECL void	MZ (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q)
	(External API) Multiple "Z" Gate More...

MICROSOFT_QUANTUM_DECL void	R (_In_ uintq sid, _In_ uintq b, _In_ double phi, _In_ uintq q)
	(External API) Rotation around Pauli axes More...

MICROSOFT_QUANTUM_DECL void	MCR (_In_ uintq sid, _In_ uintq b, _In_ double phi, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
	(External API) Controlled rotation around Pauli axes More...

MICROSOFT_QUANTUM_DECL void	Exp (_In_ uintq sid, _In_ uintq n, _In_reads_(n) int b, _In_ double phi, _In_reads_(n) uintq q)
	(External API) Exponentiation of Pauli operators More...

MICROSOFT_QUANTUM_DECL void	MCExp (_In_ uintq sid, _In_ uintq n, _In_reads_(n) int b, _In_ double phi, _In_ uintq nc, _In_reads_(nc) uintq cs, _In_reads_(n) uintq *q)
	(External API) Controlled exponentiation of Pauli operators More...

MICROSOFT_QUANTUM_DECL uintq	M (_In_ uintq sid, _In_ uintq q)
	(External API) Measure bit in \|0>/\|1> basis More...

MICROSOFT_QUANTUM_DECL uintq	ForceM (_In_ uintq sid, _In_ uintq q, _In_ bool r)
	(External API) PSEUDO-QUANTUM: Post-select bit in \|0>/\|1> basis More...

MICROSOFT_QUANTUM_DECL uintq	MAll (_In_ uintq sid)
	(External API) Measure all bits separately in \|0>/\|1> basis, and return the result in low-to-high order corresponding with first-to-last in original order of allocation. More...

MICROSOFT_QUANTUM_DECL uintq	Measure (_In_ uintq sid, _In_ uintq n, _In_reads_(n) int b, _In_reads_(n) uintq q)
	(External API) Measure bits in specified Pauli bases More...

MICROSOFT_QUANTUM_DECL void	MeasureShots (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq q, _In_ uintq s, _In_reads_(s) uintq m)

MICROSOFT_QUANTUM_DECL void	SWAP (_In_ uintq sid, _In_ uintq qi1, _In_ uintq qi2)

MICROSOFT_QUANTUM_DECL void	ISWAP (_In_ uintq sid, _In_ uintq qi1, _In_ uintq qi2)

MICROSOFT_QUANTUM_DECL void	AdjISWAP (_In_ uintq sid, _In_ uintq qi1, _In_ uintq qi2)

MICROSOFT_QUANTUM_DECL void	FSim (_In_ uintq sid, _In_ double theta, _In_ double phi, _In_ uintq qi1, _In_ uintq qi2)

MICROSOFT_QUANTUM_DECL void	CSWAP (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq qi1, _In_ uintq qi2)

MICROSOFT_QUANTUM_DECL void	ACSWAP (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq qi1, _In_ uintq qi2)

MICROSOFT_QUANTUM_DECL void	Compose (_In_ uintq sid1, _In_ uintq sid2, uintq *q)

MICROSOFT_QUANTUM_DECL uintq	Decompose (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q)

MICROSOFT_QUANTUM_DECL void	Dispose (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q)

MICROSOFT_QUANTUM_DECL void	AND (_In_ uintq sid, _In_ uintq qi1, _In_ uintq qi2, _In_ uintq qo)

MICROSOFT_QUANTUM_DECL void	OR (_In_ uintq sid, _In_ uintq qi1, _In_ uintq qi2, _In_ uintq qo)

MICROSOFT_QUANTUM_DECL void	XOR (_In_ uintq sid, _In_ uintq qi1, _In_ uintq qi2, _In_ uintq qo)

MICROSOFT_QUANTUM_DECL void	NAND (_In_ uintq sid, _In_ uintq qi1, _In_ uintq qi2, _In_ uintq qo)

MICROSOFT_QUANTUM_DECL void	NOR (_In_ uintq sid, _In_ uintq qi1, _In_ uintq qi2, _In_ uintq qo)

MICROSOFT_QUANTUM_DECL void	XNOR (_In_ uintq sid, _In_ uintq qi1, _In_ uintq qi2, _In_ uintq qo)

MICROSOFT_QUANTUM_DECL void	CLAND (_In_ uintq sid, _In_ bool ci, _In_ uintq qi, _In_ uintq qo)

MICROSOFT_QUANTUM_DECL void	CLOR (_In_ uintq sid, _In_ bool ci, _In_ uintq qi, _In_ uintq qo)

MICROSOFT_QUANTUM_DECL void	CLXOR (_In_ uintq sid, _In_ bool ci, _In_ uintq qi, _In_ uintq qo)

MICROSOFT_QUANTUM_DECL void	CLNAND (_In_ uintq sid, _In_ bool ci, _In_ uintq qi, _In_ uintq qo)

MICROSOFT_QUANTUM_DECL void	CLNOR (_In_ uintq sid, _In_ bool ci, _In_ uintq qi, _In_ uintq qo)

MICROSOFT_QUANTUM_DECL void	CLXNOR (_In_ uintq sid, _In_ bool ci, _In_ uintq qi, _In_ uintq qo)

double	_Prob (_In_ uintq sid, _In_ uintq q, bool isRdm)

MICROSOFT_QUANTUM_DECL double	Prob (_In_ uintq sid, _In_ uintq q)
	(External API) Get the probability that a qubit is in the \|1> state. More...

MICROSOFT_QUANTUM_DECL double	ProbRdm (_In_ uintq sid, _In_ uintq q)
	(External API) Get the probability that a qubit is in the \|1> state, treating all ancillary qubits as post-selected T gate gadgets. More...

double	_PermutationProb (uintq sid, uintq n, uintq q, bool c, bool isRdm, bool r)

MICROSOFT_QUANTUM_DECL double	PermutationProb (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq q, _In_reads_(n) bool c)
	(External API) Get the permutation expectation value, based upon the order of input qubits. More...

MICROSOFT_QUANTUM_DECL double	PermutationProbRdm (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq q, _In_reads_(n) bool c, _In_ bool r)
	(External API) Get the permutation expectation value, based upon the order of input qubits, treating all ancillary qubits as post-selected T gate gadgets. More...

double	_PermutationExpectation (uintq sid, uintq n, uintq *q, bool r, bool isRdm)

MICROSOFT_QUANTUM_DECL double	PermutationExpectation (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q)
	(External API) Get the permutation expectation value, based upon the order of input qubits. More...

MICROSOFT_QUANTUM_DECL double	PermutationExpectationRdm (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, bool r)
	(External API) Get the permutation expectation value, based upon the order of input qubits, treating all ancillary qubits as post-selected T gate gadgets. More...

double	_FactorizedExpectation (uintq sid, uintq n, uintq q, uintq m, uintq c, real1_f *f, bool r, bool isRdm)

MICROSOFT_QUANTUM_DECL double	FactorizedExpectation (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq q, _In_ uintq m, uintq c)
	(External API) Get the permutation expectation value, based upon the order of input qubits. More...

MICROSOFT_QUANTUM_DECL double	FactorizedExpectationRdm (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq q, _In_ uintq m, uintq c, _In_ bool r)
	(External API) Get the permutation expectation value, based upon the order of input qubits, treating all ancillary qubits as post-selected T gate gadgets. More...

MICROSOFT_QUANTUM_DECL double	FactorizedExpectationFp (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq q, real1_f c)
	(External API) Get the permutation expectation value, based upon the order of input qubits. More...

MICROSOFT_QUANTUM_DECL double	FactorizedExpectationFpRdm (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq q, real1_f c, _In_ bool r)
	(External API) Get the permutation expectation value, based upon the order of input qubits, treating all ancillary qubits as post-selected T gate gadgets. More...

MICROSOFT_QUANTUM_DECL void	QFT (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c)

MICROSOFT_QUANTUM_DECL void	IQFT (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c)

MICROSOFT_QUANTUM_DECL void	ADD (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_ uintq n, _In_reads_(n) uintq q)

MICROSOFT_QUANTUM_DECL void	SUB (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_ uintq n, _In_reads_(n) uintq q)

MICROSOFT_QUANTUM_DECL void	ADDS (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, uintq s, _In_ uintq n, _In_reads_(n) uintq q)

MICROSOFT_QUANTUM_DECL void	SUBS (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, uintq s, _In_ uintq n, _In_reads_(n) uintq q)

MICROSOFT_QUANTUM_DECL void	MCADD (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_ uintq nc, _In_reads_(nc) uintq c, _In_ uintq nq, _In_reads_(nq) uintq *q)

MICROSOFT_QUANTUM_DECL void	MCSUB (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_ uintq nc, _In_reads_(nc) uintq c, _In_ uintq nq, _In_reads_(nq) uintq *q)

MICROSOFT_QUANTUM_DECL void	MUL (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_ uintq n, _In_reads_(n) uintq q, _In_reads_(n) uintq *o)

MICROSOFT_QUANTUM_DECL void	DIV (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_ uintq n, _In_reads_(n) uintq q, _In_reads_(n) uintq *o)

MICROSOFT_QUANTUM_DECL void	MULN (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_reads_(na) uintq m, _In_ uintq n, _In_reads_(n) uintq q, _In_reads_(n) uintq o)

MICROSOFT_QUANTUM_DECL void	DIVN (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_reads_(na) uintq m, _In_ uintq n, _In_reads_(n) uintq q, _In_reads_(n) uintq o)

MICROSOFT_QUANTUM_DECL void	POWN (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_reads_(na) uintq m, _In_ uintq n, _In_reads_(n) uintq q, _In_reads_(n) uintq o)

MICROSOFT_QUANTUM_DECL void	MCMUL (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_ uintq nc, _In_reads_(nc) uintq c, _In_ uintq n, _In_reads_(n) uintq q, _In_reads_(n) uintq o)

MICROSOFT_QUANTUM_DECL void	MCDIV (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_ uintq nc, _In_reads_(nc) uintq c, _In_ uintq n, _In_reads_(n) uintq q, _In_reads_(n) uintq o)

MICROSOFT_QUANTUM_DECL void	MCMULN (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_ uintq nc, _In_reads_(nc) uintq c, _In_reads_(na) uintq m, _In_ uintq n, _In_reads_(n) uintq q, _In_reads_(n) uintq *o)

MICROSOFT_QUANTUM_DECL void	MCDIVN (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_ uintq nc, _In_reads_(nc) uintq c, _In_reads_(na) uintq m, _In_ uintq n, _In_reads_(n) uintq q, _In_reads_(n) uintq *o)

MICROSOFT_QUANTUM_DECL void	MCPOWN (_In_ uintq sid, _In_ uintq na, _In_reads_(na) uintq a, _In_ uintq nc, _In_reads_(nc) uintq c, _In_reads_(na) uintq m, _In_ uintq n, _In_reads_(n) uintq q, _In_reads_(n) uintq *o)

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)

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)

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)

MICROSOFT_QUANTUM_DECL void	Hash (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq q, unsigned char t)

MICROSOFT_QUANTUM_DECL bool	TrySeparate1Qb (_In_ uintq sid, _In_ uintq qi1)

MICROSOFT_QUANTUM_DECL bool	TrySeparate2Qb (_In_ uintq sid, _In_ uintq qi1, _In_ uintq qi2)

MICROSOFT_QUANTUM_DECL bool	TrySeparateTol (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_ double tol)

MICROSOFT_QUANTUM_DECL double	GetUnitaryFidelity (_In_ uintq sid)

MICROSOFT_QUANTUM_DECL void	ResetUnitaryFidelity (_In_ uintq sid)

MICROSOFT_QUANTUM_DECL void	SetSdrp (_In_ uintq sid, _In_ double sdrp)

MICROSOFT_QUANTUM_DECL void	SetReactiveSeparate (_In_ uintq sid, _In_ bool irs)

MICROSOFT_QUANTUM_DECL void	SetTInjection (_In_ uintq sid, _In_ bool irs)

MICROSOFT_QUANTUM_DECL uintq	init_qneuron (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q, _In_ uintq f, _In_ double a, _In_ double tol)

MICROSOFT_QUANTUM_DECL uintq	clone_qneuron (_In_ uintq nid)

MICROSOFT_QUANTUM_DECL void	destroy_qneuron (_In_ uintq nid)

MICROSOFT_QUANTUM_DECL void	set_qneuron_angles (_In_ uintq nid, _In_ float *angles)

MICROSOFT_QUANTUM_DECL void	get_qneuron_angles (_In_ uintq nid, _In_ float *angles)

MICROSOFT_QUANTUM_DECL void	set_qneuron_alpha (_In_ uintq nid, _In_ double alpha)

MICROSOFT_QUANTUM_DECL double	get_qneuron_alpha (_In_ uintq nid)

MICROSOFT_QUANTUM_DECL void	set_qneuron_activation_fn (_In_ uintq nid, _In_ uintq f)

MICROSOFT_QUANTUM_DECL uintq	get_qneuron_activation_fn (_In_ uintq nid)

MICROSOFT_QUANTUM_DECL double	qneuron_predict (_In_ uintq nid, _In_ bool e, _In_ bool r)

MICROSOFT_QUANTUM_DECL double	qneuron_unpredict (_In_ uintq nid, _In_ bool e)

MICROSOFT_QUANTUM_DECL double	qneuron_learn_cycle (_In_ uintq nid, _In_ bool e)

MICROSOFT_QUANTUM_DECL void	qneuron_learn (_In_ uintq nid, _In_ double eta, _In_ bool e, _In_ bool r)

MICROSOFT_QUANTUM_DECL void	qneuron_learn_permutation (_In_ uintq nid, _In_ double eta, _In_ bool e, _In_ bool r)

MICROSOFT_QUANTUM_DECL uintq	init_qcircuit (_In_ bool collapse, _In_ bool clifford)

uintq	_init_qcircuit_copy (uintq cid, bool isInverse, std::set< bitLenInt > q)

MICROSOFT_QUANTUM_DECL uintq	init_qcircuit_clone (_In_ uintq cid)

MICROSOFT_QUANTUM_DECL uintq	qcircuit_inverse (_In_ uintq cid)

MICROSOFT_QUANTUM_DECL uintq	qcircuit_past_light_cone (_In_ uintq cid, _In_ uintq n, _In_reads_(n) uintq *q)

MICROSOFT_QUANTUM_DECL void	destroy_qcircuit (_In_ uintq cid)

MICROSOFT_QUANTUM_DECL uintq	get_qcircuit_qubit_count (_In_ uintq cid)

MICROSOFT_QUANTUM_DECL void	qcircuit_swap (_In_ uintq cid, _In_ uintq q1, _In_ uintq q2)

MICROSOFT_QUANTUM_DECL void	qcircuit_append_1qb (_In_ uintq cid, _In_reads_(8) double *m, _In_ uintq q)

MICROSOFT_QUANTUM_DECL void	qcircuit_append_mc (_In_ uintq cid, _In_reads_(8) double m, _In_ uintq n, _In_reads_(n) uintq c, _In_ uintq q, _In_ uintq p)

MICROSOFT_QUANTUM_DECL void	qcircuit_run (_In_ uintq cid, _In_ uintq sid)

MICROSOFT_QUANTUM_DECL void	qcircuit_out_to_file (_In_ uintq cid, _In_ char *f)

MICROSOFT_QUANTUM_DECL void	qcircuit_in_from_file (_In_ uintq cid, _In_ char *f)

Variables
qrack_rand_gen_ptr	randNumGen = std::make_shared<qrack_rand_gen>(time(0))

std::mutex	metaOperationMutex

int	metaError = 0

std::vector< int >	simulatorErrors

std::vector< QInterfacePtr >	simulators

std::vector< std::vector< QInterfaceEngine > >	simulatorTypes

std::vector< bool >	simulatorHostPointer

std::map< QInterface *, std::mutex >	simulatorMutexes

std::vector< bool >	simulatorReservations

std::map< QInterface *, std::map< uintq, bitLenInt > >	shards

std::vector< int >	neuronErrors

std::vector< QNeuronPtr >	neurons

std::map< QNeuronPtr, QInterface * >	neuronSimulators

std::map< QNeuron *, std::mutex >	neuronMutexes

std::vector< bool >	neuronReservations

std::vector< QCircuitPtr >	circuits

std::map< QCircuit *, std::mutex >	circuitMutexes

std::vector< bool >	circuitReservations

bitLenInt	_maxShardQubits = 0U

Macro Definition Documentation

◆ CIRCUIT_AND_SIMULATOR_LOCK_GUARD_VOID

#define CIRCUIT_AND_SIMULATOR_LOCK_GUARD_VOID	(	cid,
		sid
	)

Value:

    if (sid > simulators.size()) {                                                                                     \
        std::cout << "Invalid argument: simulator ID not found!" << std::endl;                                         \
        metaError = 2;                                                                                                 \
        return;                                                                                                        \
    }                                                                                                                  \
    if (cid > circuits.size()) {                                                                                       \
        std::cout << "Invalid argument: neuron ID not found!" << std::endl;                                            \
        metaError = 2;                                                                                                 \
        return;                                                                                                        \
    }                                                                                                                  \
                                                                                                                       \
    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;                                                                                                        \
    }

◆ 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()) {                                                                                       \
        std::cout << "Invalid argument: circuit ID not found!" << std::endl;                                           \
        metaError = 2;                                                                                                 \
        return def;                                                                                                    \
    }                                                                                                                  \
                                                                                                                       \
    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()) {                                                                                       \
        std::cout << "Invalid argument: neuron ID not found!" << std::endl;                                            \
        metaError = 2;                                                                                                 \
        return;                                                                                                        \
    }                                                                                                                  \
                                                                                                                       \
    QCircuitPtr circuit = circuits[cid];                                                                               \
    CIRCUIT_LOCK_GUARD(circuit)                                                                                        \
    if (!circuit) {                                                                                                    \
        return;                                                                                                        \
    }

◆ MAP_CONTROLS_AND_LOCK

#define MAP_CONTROLS_AND_LOCK	(	sid,
		numC
	)

Value:

    SIMULATOR_LOCK_GUARD_VOID(sid)                                                                                     \
    std::vector<bitLenInt> ctrlsArray(numC);                                                                           \
    for (uintq i = 0; i < numC; ++i) {                                                                                 \
        ctrlsArray[i] = shards[simulator.get()][c[i]];                                                                 \
    }

◆ MAP_MASK_AND_LOCK

#define MAP_MASK_AND_LOCK	(	sid,
		numQ
	)

Value:

    SIMULATOR_LOCK_GUARD_VOID(sid)                                                                                     \
    bitCapInt mask = 0U;                                                                                               \
    for (uintq i = 0U; i < numQ; ++i) {                                                                                \
        mask |= pow2(shards[simulator.get()][q[i]]);                                                                   \
    }

◆ 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));       \
    }

◆ NEURON_LOCK_GUARD_DOUBLE

#define NEURON_LOCK_GUARD_DOUBLE ( nid ) NEURON_LOCK_GUARD_TYPED(nid, 0.0)

◆ NEURON_LOCK_GUARD_INT

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

◆ NEURON_LOCK_GUARD_TYPED

#define NEURON_LOCK_GUARD_TYPED	(	nid,
		def
	)

Value:

    if (nid > neurons.size()) {                                                                                        \
        std::cout << "Invalid argument: neuron ID not found!" << std::endl;                                            \
        metaError = 2;                                                                                                 \
        return def;                                                                                                    \
    }                                                                                                                  \
                                                                                                                       \
    QNeuronPtr neuron = neurons[nid];                                                                                  \
    NEURON_LOCK_GUARD(neuron)                                                                                          \
    if (!neuron) {                                                                                                     \
        return def;                                                                                                    \
    }

◆ NEURON_LOCK_GUARD_VOID

#define NEURON_LOCK_GUARD_VOID ( nid )

Value:

    if (nid > neurons.size()) {                                                                                        \
        std::cout << "Invalid argument: neuron ID not found!" << std::endl;                                            \
        metaError = 2;                                                                                                 \
        return;                                                                                                        \
    }                                                                                                                  \
                                                                                                                       \
    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_DOUBLE

#define SIMULATOR_LOCK_GUARD_DOUBLE ( sid ) SIMULATOR_LOCK_GUARD_TYPED(sid, 0.0)

◆ SIMULATOR_LOCK_GUARD_INT

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

◆ SIMULATOR_LOCK_GUARD_TYPED

#define SIMULATOR_LOCK_GUARD_TYPED	(	sid,
		def
	)

Value:

    if (sid > simulators.size()) {                                                                                     \
        std::cout << "Invalid argument: simulator ID not found!" << std::endl;                                         \
        metaError = 2;                                                                                                 \
        return def;                                                                                                    \
    }                                                                                                                  \
                                                                                                                       \
    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()) {                                                                                     \
        std::cout << "Invalid argument: simulator ID not found!" << std::endl;                                         \
        metaError = 2;                                                                                                 \
        return;                                                                                                        \
    }                                                                                                                  \
    QInterfacePtr simulator = simulators[sid];                                                                         \
    SIMULATOR_LOCK_GUARD(simulator.get())                                                                              \
    if (!simulator) {                                                                                                  \
        return;                                                                                                        \
    }

Function Documentation

◆ _combineA()

bitCapInt _combineA	(	uintq	na,
		const uintq *	a
	)

◆ _darray_to_creal1_array()

void _darray_to_creal1_array	(	double *	params,
		bitCapIntOcl	componentCount,
		complex *	amps
	)

◆ _FactorizedExpectation()

double _FactorizedExpectation	(	uintq	sid,
		uintq	n,
		uintq *	q,
		uintq	m,
		uintq *	c,
		real1_f *	f,
		bool	r,
		bool	isRdm
	)

◆ _init_qcircuit_copy()

uintq _init_qcircuit_copy	(	uintq	cid,
		bool	isInverse,
		std::set< bitLenInt >	q
	)

◆ _JointEnsembleProbabilityHelper()

double _JointEnsembleProbabilityHelper	(	QInterfacePtr	simulator,
		uintq	n,
		int *	b,
		uintq *	q,
		bool	doMeasure
	)

◆ _PermutationExpectation()

double _PermutationExpectation	(	uintq	sid,
		uintq	n,
		uintq *	q,
		bool	r,
		bool	isRdm
	)

◆ _PermutationProb()

double _PermutationProb	(	uintq	sid,
		uintq	n,
		uintq *	q,
		bool *	c,
		bool	isRdm,
		bool	r
	)

◆ _Prob()

double _Prob	(	_In_ uintq	sid,
		_In_ uintq	q,
		bool	isRdm
	)

◆ ACSWAP()

MICROSOFT_QUANTUM_DECL void ACSWAP	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	qi1,
		_In_ uintq	qi2
	)

◆ 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
	)

◆ ADD()

MICROSOFT_QUANTUM_DECL void ADD	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q
	)

◆ ADDS()

MICROSOFT_QUANTUM_DECL void ADDS	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		uintq	s,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q
	)

◆ AdjISWAP()

MICROSOFT_QUANTUM_DECL void AdjISWAP	(	_In_ uintq	sid,
		_In_ uintq	qi1,
		_In_ uintq	qi2
	)

◆ AdjS()

MICROSOFT_QUANTUM_DECL void AdjS	(	_In_ uintq	sid,
		_In_ uintq	q
	)

(External API) Inverse "S" Gate

◆ AdjT()

MICROSOFT_QUANTUM_DECL void AdjT	(	_In_ uintq	sid,
		_In_ uintq	q
	)

(External API) Inverse "T" Gate

◆ allocateQubit()

MICROSOFT_QUANTUM_DECL void allocateQubit	(	_In_ uintq	sid,
		_In_ uintq	qid
	)

(External API) Allocate 1 new qubit with the given qubit ID, under the simulator ID

◆ AND()

MICROSOFT_QUANTUM_DECL void AND	(	_In_ uintq	sid,
		_In_ uintq	qi1,
		_In_ uintq	qi2,
		_In_ uintq	qo
	)

◆ CLAND()

MICROSOFT_QUANTUM_DECL void CLAND	(	_In_ uintq	sid,
		_In_ bool	ci,
		_In_ uintq	qi,
		_In_ uintq	qo
	)

◆ CLNAND()

MICROSOFT_QUANTUM_DECL void CLNAND	(	_In_ uintq	sid,
		_In_ bool	ci,
		_In_ uintq	qi,
		_In_ uintq	qo
	)

◆ CLNOR()

MICROSOFT_QUANTUM_DECL void CLNOR	(	_In_ uintq	sid,
		_In_ bool	ci,
		_In_ uintq	qi,
		_In_ uintq	qo
	)

◆ clone_qneuron()

MICROSOFT_QUANTUM_DECL uintq clone_qneuron ( _In_ uintq nid )

◆ CLOR()

MICROSOFT_QUANTUM_DECL void CLOR	(	_In_ uintq	sid,
		_In_ bool	ci,
		_In_ uintq	qi,
		_In_ uintq	qo
	)

◆ CLXNOR()

MICROSOFT_QUANTUM_DECL void CLXNOR	(	_In_ uintq	sid,
		_In_ bool	ci,
		_In_ uintq	qi,
		_In_ uintq	qo
	)

◆ CLXOR()

MICROSOFT_QUANTUM_DECL void CLXOR	(	_In_ uintq	sid,
		_In_ bool	ci,
		_In_ uintq	qi,
		_In_ uintq	qo
	)

◆ Compose()

MICROSOFT_QUANTUM_DECL void Compose	(	_In_ uintq	sid1,
		_In_ uintq	sid2,
		uintq *	q
	)

◆ CSWAP()

MICROSOFT_QUANTUM_DECL void CSWAP	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	qi1,
		_In_ uintq	qi2
	)

◆ Decompose()

MICROSOFT_QUANTUM_DECL uintq Decompose	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q
	)

◆ destroy()

MICROSOFT_QUANTUM_DECL void destroy ( _In_ uintq sid )

(External API) Destroy a simulator (ID will not be reused)

◆ destroy_qcircuit()

MICROSOFT_QUANTUM_DECL void destroy_qcircuit ( _In_ uintq cid )

◆ destroy_qneuron()

MICROSOFT_QUANTUM_DECL void destroy_qneuron ( _In_ uintq nid )

◆ Dispose()

MICROSOFT_QUANTUM_DECL void Dispose	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q
	)

◆ DIV()

MICROSOFT_QUANTUM_DECL void DIV	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(n) uintq *	o
	)

◆ DIVN()

MICROSOFT_QUANTUM_DECL void DIVN	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_reads_(na) uintq *	m,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(n) uintq *	o
	)

◆ Dump()

MICROSOFT_QUANTUM_DECL void Dump	(	_In_ uintq	sid,
		_In_ ProbAmpCallback	callback
	)

(External API) "Dump" state vector from the selected simulator ID into the callback

◆ DumpIds()

MICROSOFT_QUANTUM_DECL void DumpIds	(	_In_ uintq	sid,
		_In_ IdCallback	callback
	)

(External API) "Dump" all IDs from the selected simulator ID into the callback

◆ Exp()

MICROSOFT_QUANTUM_DECL void Exp	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) int *	b,
		_In_ double	phi,
		_In_reads_(n) uintq *	q
	)

(External API) Exponentiation of Pauli operators

◆ FactorizedExpectation()

MICROSOFT_QUANTUM_DECL double FactorizedExpectation	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_ uintq	m,
		uintq *	c
	)

(External API) Get the permutation expectation value, based upon the order of input qubits.

◆ FactorizedExpectationFp()

MICROSOFT_QUANTUM_DECL double FactorizedExpectationFp	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		real1_f *	c
	)

(External API) Get the permutation expectation value, based upon the order of input qubits.

◆ FactorizedExpectationFpRdm()

MICROSOFT_QUANTUM_DECL double FactorizedExpectationFpRdm	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		real1_f *	c,
		_In_ bool	r
	)

(External API) Get the permutation expectation value, based upon the order of input qubits, treating all ancillary qubits as post-selected T gate gadgets.

◆ FactorizedExpectationRdm()

MICROSOFT_QUANTUM_DECL double FactorizedExpectationRdm	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_ uintq	m,
		uintq *	c,
		_In_ bool	r
	)

(External API) Get the permutation expectation value, based upon the order of input qubits, treating all ancillary qubits as post-selected T gate gadgets.

◆ FindShardValue()

std::map<uintq, bitLenInt>::iterator FindShardValue	(	bitLenInt	v,
		std::map< uintq, bitLenInt > &	simMap
	)

◆ ForceM()

MICROSOFT_QUANTUM_DECL uintq ForceM	(	_In_ uintq	sid,
		_In_ uintq	q,
		_In_ bool	r
	)

(External API) PSEUDO-QUANTUM: Post-select bit in |0>/|1> basis

◆ FSim()

MICROSOFT_QUANTUM_DECL void FSim	(	_In_ uintq	sid,
		_In_ double	theta,
		_In_ double	phi,
		_In_ uintq	qi1,
		_In_ uintq	qi2
	)

◆ get_error()

MICROSOFT_QUANTUM_DECL int get_error ( _In_ uintq sid )

(External API) Poll after each operation to check whether error occurred.

◆ get_qcircuit_qubit_count()

MICROSOFT_QUANTUM_DECL uintq get_qcircuit_qubit_count ( _In_ uintq cid )

◆ get_qneuron_activation_fn()

MICROSOFT_QUANTUM_DECL uintq get_qneuron_activation_fn ( _In_ uintq nid )

◆ get_qneuron_alpha()

MICROSOFT_QUANTUM_DECL double get_qneuron_alpha ( _In_ uintq nid )

◆ get_qneuron_angles()

MICROSOFT_QUANTUM_DECL void get_qneuron_angles	(	_In_ uintq	nid,
		_In_ float *	angles
	)

◆ GetUnitaryFidelity()

MICROSOFT_QUANTUM_DECL double GetUnitaryFidelity ( _In_ uintq sid )

◆ H()

MICROSOFT_QUANTUM_DECL void H	(	_In_ uintq	sid,
		_In_ uintq	q
	)

(External API) Walsh-Hadamard transform applied for simulator ID and qubit ID

◆ Hash()

MICROSOFT_QUANTUM_DECL void Hash	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		unsigned char *	t
	)

◆ init_clone()

MICROSOFT_QUANTUM_DECL uintq init_clone ( _In_ uintq sid )

(External API) Initialize a simulator ID that clones simulator ID "sid"

◆ init_count()

MICROSOFT_QUANTUM_DECL uintq init_count	(	_In_ uintq	q,
		_In_ bool	hp
	)

(External API) Initialize a simulator ID with "q" qubits and implicit default layer options.

◆ init_count_pager()

MICROSOFT_QUANTUM_DECL uintq init_count_pager	(	_In_ uintq	q,
		_In_ bool	hp
	)

(External API) Initialize a simulator ID with "q" qubits and implicit default layer options.

◆ init_count_type()

MICROSOFT_QUANTUM_DECL uintq init_count_type	(	_In_ uintq	q,
		_In_ bool	tn,
		_In_ bool	md,
		_In_ bool	sd,
		_In_ bool	sh,
		_In_ bool	bdt,
		_In_ bool	pg,
		_In_ bool	zxf,
		_In_ bool	hy,
		_In_ bool	oc,
		_In_ bool	hp
	)

(External API) Initialize a simulator ID with "q" qubits and explicit layer options on/off

◆ init_qcircuit()

MICROSOFT_QUANTUM_DECL uintq init_qcircuit	(	_In_ bool	collapse,
		_In_ bool	clifford
	)

◆ init_qcircuit_clone()

MICROSOFT_QUANTUM_DECL uintq init_qcircuit_clone ( _In_ uintq cid )

◆ init_qneuron()

MICROSOFT_QUANTUM_DECL uintq init_qneuron	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q,
		_In_ uintq	f,
		_In_ double	a,
		_In_ double	tol
	)

◆ InKet()

MICROSOFT_QUANTUM_DECL void InKet	(	_In_ uintq	sid,
		_In_ real1_f *	ket
	)

(External API) Set state vector for the selected simulator ID.

◆ IQFT()

MICROSOFT_QUANTUM_DECL void IQFT	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c
	)

◆ ISWAP()

MICROSOFT_QUANTUM_DECL void ISWAP	(	_In_ uintq	sid,
		_In_ uintq	qi1,
		_In_ uintq	qi2
	)

◆ JointEnsembleProbability()

MICROSOFT_QUANTUM_DECL double JointEnsembleProbability	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) int *	b,
		_In_reads_(n) uintq *	q
	)

(External API) Find the joint probability for all specified qubits under the respective Pauli basis transformations.

◆ 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
	)

◆ M()

MICROSOFT_QUANTUM_DECL uintq M	(	_In_ uintq	sid,
		_In_ uintq	q
	)

(External API) Measure bit in |0>/|1> basis

◆ MACAdjS()

MICROSOFT_QUANTUM_DECL void MACAdjS	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) "Anti-"Controlled Inverse "S" Gate

◆ MACAdjT()

MICROSOFT_QUANTUM_DECL void MACAdjT	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) "Anti-"Controlled Inverse "T" Gate

◆ MACH()

MICROSOFT_QUANTUM_DECL void MACH	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) "Anti-"Controlled "H" Gate

◆ MACMtrx()

MICROSOFT_QUANTUM_DECL void MACMtrx	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_reads_(8) double *	m,
		_In_ uintq	q
	)

(External API) Controlled 2x2 complex matrix unitary gate

◆ MACS()

MICROSOFT_QUANTUM_DECL void MACS	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) "Anti-"Controlled "S" Gate

◆ MACT()

MICROSOFT_QUANTUM_DECL void MACT	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) "Anti-"Controlled "T" Gate

◆ MACU()

MICROSOFT_QUANTUM_DECL void MACU	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q,
		_In_ double	theta,
		_In_ double	phi,
		_In_ double	lambda
	)

(External API) Controlled 3-parameter unitary gate

◆ MACX()

MICROSOFT_QUANTUM_DECL void MACX	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) "Anti-"Controlled "X" Gate

◆ MACY()

MICROSOFT_QUANTUM_DECL void MACY	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) "Anti-"Controlled "Y" Gate

◆ MACZ()

MICROSOFT_QUANTUM_DECL void MACZ	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) "Anti-"Controlled "Z" Gate

◆ make_mask()

std::size_t make_mask ( std::vector< bitLenInt > const & qs )

inline

◆ MAll()

MICROSOFT_QUANTUM_DECL uintq MAll ( _In_ uintq sid )

(External API) Measure all bits separately in |0>/|1> basis, and return the result in low-to-high order corresponding with first-to-last in original order of allocation.

◆ MapArithmetic()

uintq MapArithmetic	(	QInterfacePtr	simulator,
		uintq	n,
		uintq *	q
	)

◆ MapArithmetic2()

MapArithmeticResult2 MapArithmetic2	(	QInterfacePtr	simulator,
		uintq	n,
		uintq *	q1,
		uintq *	q2
	)

◆ MapArithmetic3()

MapArithmeticResult2 MapArithmetic3	(	QInterfacePtr	simulator,
		uintq	n1,
		uintq *	q1,
		uintq	n2,
		uintq *	q2
	)

◆ MaxShardQubits()

bitLenInt MaxShardQubits ( )

◆ MCADD()

MICROSOFT_QUANTUM_DECL void MCADD	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_ uintq	nc,
		_In_reads_(nc) uintq *	c,
		_In_ uintq	nq,
		_In_reads_(nq) uintq *	q
	)

◆ MCAdjS()

MICROSOFT_QUANTUM_DECL void MCAdjS	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) Controlled Inverse "S" Gate

◆ MCAdjT()

MICROSOFT_QUANTUM_DECL void MCAdjT	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) Controlled Inverse "T" Gate

◆ MCDIV()

MICROSOFT_QUANTUM_DECL void MCDIV	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_ uintq	nc,
		_In_reads_(nc) uintq *	c,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(n) uintq *	o
	)

◆ MCDIVN()

MICROSOFT_QUANTUM_DECL void MCDIVN	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_ uintq	nc,
		_In_reads_(nc) uintq *	c,
		_In_reads_(na) uintq *	m,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(n) uintq *	o
	)

◆ MCExp()

MICROSOFT_QUANTUM_DECL void MCExp	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) int *	b,
		_In_ double	phi,
		_In_ uintq	nc,
		_In_reads_(nc) uintq *	cs,
		_In_reads_(n) uintq *	q
	)

(External API) Controlled exponentiation of Pauli operators

◆ MCH()

MICROSOFT_QUANTUM_DECL void MCH	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) Controlled "H" Gate

◆ MCMtrx()

MICROSOFT_QUANTUM_DECL void MCMtrx	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_reads_(8) double *	m,
		_In_ uintq	q
	)

(External API) Controlled 2x2 complex matrix unitary gate

◆ MCMUL()

MICROSOFT_QUANTUM_DECL void MCMUL	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_ uintq	nc,
		_In_reads_(nc) uintq *	c,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(n) uintq *	o
	)

◆ MCMULN()

MICROSOFT_QUANTUM_DECL void MCMULN	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_ uintq	nc,
		_In_reads_(nc) uintq *	c,
		_In_reads_(na) uintq *	m,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(n) uintq *	o
	)

◆ MCPOWN()

MICROSOFT_QUANTUM_DECL void MCPOWN	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_ uintq	nc,
		_In_reads_(nc) uintq *	c,
		_In_reads_(na) uintq *	m,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(n) uintq *	o
	)

◆ MCR()

MICROSOFT_QUANTUM_DECL void MCR	(	_In_ uintq	sid,
		_In_ uintq	b,
		_In_ double	phi,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) Controlled rotation around Pauli axes

◆ MCRHelper()

void MCRHelper	(	uintq	sid,
		uintq	b,
		double	phi,
		uintq	n,
		uintq *	c,
		uintq	q
	)

◆ MCS()

MICROSOFT_QUANTUM_DECL void MCS	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) Controlled "S" Gate

◆ MCSUB()

MICROSOFT_QUANTUM_DECL void MCSUB	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_ uintq	nc,
		_In_reads_(nc) uintq *	c,
		_In_ uintq	nq,
		_In_reads_(nq) uintq *	q
	)

◆ MCT()

MICROSOFT_QUANTUM_DECL void MCT	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) Controlled "T" Gate

◆ MCU()

MICROSOFT_QUANTUM_DECL void MCU	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q,
		_In_ double	theta,
		_In_ double	phi,
		_In_ double	lambda
	)

(External API) Controlled 3-parameter unitary gate

◆ MCX()

MICROSOFT_QUANTUM_DECL void MCX	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) Controlled "X" Gate

◆ MCY()

MICROSOFT_QUANTUM_DECL void MCY	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) Controlled "Y" Gate

◆ MCZ()

MICROSOFT_QUANTUM_DECL void MCZ	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q
	)

(External API) Controlled "Z" Gate

◆ Measure()

MICROSOFT_QUANTUM_DECL uintq Measure	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) int *	b,
		_In_reads_(n) uintq *	q
	)

(External API) Measure bits in specified Pauli bases

◆ MeasureShots()

MICROSOFT_QUANTUM_DECL void MeasureShots	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_ uintq	s,
		_In_reads_(s) uintq *	m
	)

◆ Mtrx()

MICROSOFT_QUANTUM_DECL void Mtrx	(	_In_ uintq	sid,
		_In_reads_(8) double *	m,
		_In_ uintq	q
	)

(External API) 2x2 complex matrix unitary gate

◆ MUL()

MICROSOFT_QUANTUM_DECL void MUL	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(n) uintq *	o
	)

◆ MULN()

MICROSOFT_QUANTUM_DECL void MULN	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_reads_(na) uintq *	m,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(n) uintq *	o
	)

◆ Multiplex1Mtrx()

MICROSOFT_QUANTUM_DECL void Multiplex1Mtrx	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q,
		double *	m
	)

◆ MX()

MICROSOFT_QUANTUM_DECL void MX	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q
	)

(External API) Multiple "X" Gate

◆ MY()

MICROSOFT_QUANTUM_DECL void MY	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q
	)

(External API) Multiple "Y" Gate

◆ MZ()

MICROSOFT_QUANTUM_DECL void MZ	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q
	)

(External API) Multiple "Z" Gate

◆ NAND()

MICROSOFT_QUANTUM_DECL void NAND	(	_In_ uintq	sid,
		_In_ uintq	qi1,
		_In_ uintq	qi2,
		_In_ uintq	qo
	)

◆ NOR()

MICROSOFT_QUANTUM_DECL void NOR	(	_In_ uintq	sid,
		_In_ uintq	qi1,
		_In_ uintq	qi2,
		_In_ uintq	qo
	)

◆ num_qubits()

MICROSOFT_QUANTUM_DECL uintq num_qubits ( _In_ uintq sid )

◆ OR()

MICROSOFT_QUANTUM_DECL void OR	(	_In_ uintq	sid,
		_In_ uintq	qi1,
		_In_ uintq	qi2,
		_In_ uintq	qo
	)

◆ OutKet()

MICROSOFT_QUANTUM_DECL void OutKet	(	_In_ uintq	sid,
		_In_ real1_f *	ket
	)

(External API) Set state vector for the selected simulator ID.

◆ PermutationExpectation()

MICROSOFT_QUANTUM_DECL double PermutationExpectation	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q
	)

(External API) Get the permutation expectation value, based upon the order of input qubits.

◆ PermutationExpectationRdm()

MICROSOFT_QUANTUM_DECL double PermutationExpectationRdm	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		bool	r
	)

(External API) Get the permutation expectation value, based upon the order of input qubits, treating all ancillary qubits as post-selected T gate gadgets.

◆ PermutationProb()

MICROSOFT_QUANTUM_DECL double PermutationProb	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(n) bool *	c
	)

(External API) Get the permutation expectation value, based upon the order of input qubits.

◆ PermutationProbRdm()

MICROSOFT_QUANTUM_DECL double PermutationProbRdm	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(n) bool *	c,
		_In_ bool	r
	)

(External API) Get the permutation expectation value, based upon the order of input qubits, treating all ancillary qubits as post-selected T gate gadgets.

◆ PhaseParity()

MICROSOFT_QUANTUM_DECL void PhaseParity	(	_In_ uintq	sid,
		_In_ double	lambda,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q
	)

◆ POWN()

MICROSOFT_QUANTUM_DECL void POWN	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_reads_(na) uintq *	m,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(n) uintq *	o
	)

◆ Prob()

MICROSOFT_QUANTUM_DECL double Prob	(	_In_ uintq	sid,
		_In_ uintq	q
	)

(External API) Get the probability that a qubit is in the |1> state.

◆ ProbRdm()

MICROSOFT_QUANTUM_DECL double ProbRdm	(	_In_ uintq	sid,
		_In_ uintq	q
	)

(External API) Get the probability that a qubit is in the |1> state, treating all ancillary qubits as post-selected T gate gadgets.

◆ qcircuit_append_1qb()

MICROSOFT_QUANTUM_DECL void qcircuit_append_1qb	(	_In_ uintq	cid,
		_In_reads_(8) double *	m,
		_In_ uintq	q
	)

◆ qcircuit_append_mc()

MICROSOFT_QUANTUM_DECL void qcircuit_append_mc	(	_In_ uintq	cid,
		_In_reads_(8) double *	m,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_ uintq	q,
		_In_ uintq	p
	)

◆ qcircuit_in_from_file()

MICROSOFT_QUANTUM_DECL void qcircuit_in_from_file	(	_In_ uintq	cid,
		_In_ char *	f
	)

◆ qcircuit_inverse()

MICROSOFT_QUANTUM_DECL uintq qcircuit_inverse ( _In_ uintq cid )

◆ qcircuit_out_to_file()

MICROSOFT_QUANTUM_DECL void qcircuit_out_to_file	(	_In_ uintq	cid,
		_In_ char *	f
	)

◆ qcircuit_past_light_cone()

MICROSOFT_QUANTUM_DECL uintq qcircuit_past_light_cone	(	_In_ uintq	cid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q
	)

◆ qcircuit_run()

MICROSOFT_QUANTUM_DECL void qcircuit_run	(	_In_ uintq	cid,
		_In_ uintq	sid
	)

◆ qcircuit_swap()

MICROSOFT_QUANTUM_DECL void qcircuit_swap	(	_In_ uintq	cid,
		_In_ uintq	q1,
		_In_ uintq	q2
	)

◆ QFT()

MICROSOFT_QUANTUM_DECL void QFT	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c
	)

◆ qneuron_learn()

MICROSOFT_QUANTUM_DECL void qneuron_learn	(	_In_ uintq	nid,
		_In_ double	eta,
		_In_ bool	e,
		_In_ bool	r
	)

◆ qneuron_learn_cycle()

MICROSOFT_QUANTUM_DECL double qneuron_learn_cycle	(	_In_ uintq	nid,
		_In_ bool	e
	)

◆ qneuron_learn_permutation()

MICROSOFT_QUANTUM_DECL void qneuron_learn_permutation	(	_In_ uintq	nid,
		_In_ double	eta,
		_In_ bool	e,
		_In_ bool	r
	)

◆ qneuron_predict()

MICROSOFT_QUANTUM_DECL double qneuron_predict	(	_In_ uintq	nid,
		_In_ bool	e,
		_In_ bool	r
	)

◆ qneuron_unpredict()

MICROSOFT_QUANTUM_DECL double qneuron_unpredict	(	_In_ uintq	nid,
		_In_ bool	e
	)

◆ qstabilizer_in_from_file()

MICROSOFT_QUANTUM_DECL void qstabilizer_in_from_file	(	_In_ uintq	sid,
		_In_ char *	f
	)

◆ qstabilizer_out_to_file()

MICROSOFT_QUANTUM_DECL void qstabilizer_out_to_file	(	_In_ uintq	sid,
		_In_ char *	f
	)

◆ R()

MICROSOFT_QUANTUM_DECL void R	(	_In_ uintq	sid,
		_In_ uintq	b,
		_In_ double	phi,
		_In_ uintq	q
	)

(External API) Rotation around Pauli axes

◆ random_choice()

MICROSOFT_QUANTUM_DECL std::size_t random_choice	(	_In_ uintq	sid,
		_In_ std::size_t	n,
		_In_reads_(n) double *	p
	)

(External API) Select from a distribution of "n" elements according the discrete probabilities in "d."

◆ release()

MICROSOFT_QUANTUM_DECL bool release	(	_In_ uintq	sid,
		_In_ uintq	q
	)

(External API) Release 1 qubit with the given qubit ID, under the simulator ID

◆ removeIdentities()

void removeIdentities	(	std::vector< int > *	b,
		std::vector< bitLenInt > *	qs
	)

◆ ResetAll()

MICROSOFT_QUANTUM_DECL void ResetAll ( _In_ uintq sid )

(External API) Set the simulator to a computational basis permutation.

◆ ResetUnitaryFidelity()

MICROSOFT_QUANTUM_DECL void ResetUnitaryFidelity ( _In_ uintq sid )

◆ RevertPauliBasis()

void RevertPauliBasis	(	QInterfacePtr	simulator,
		uintq	len,
		int *	bases,
		uintq *	qubitIds
	)

◆ RHelper()

void RHelper	(	uintq	sid,
		uintq	b,
		double	phi,
		uintq	q
	)

◆ S()

MICROSOFT_QUANTUM_DECL void S	(	_In_ uintq	sid,
		_In_ uintq	q
	)

(External API) "S" Gate

◆ 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
	)

◆ seed()

MICROSOFT_QUANTUM_DECL void seed	(	_In_ uintq	sid,
		_In_ uintq	s
	)

(External API) Set RNG seed for simulator ID

◆ set_concurrency()

MICROSOFT_QUANTUM_DECL void set_concurrency	(	_In_ uintq	sid,
		_In_ uintq	p
	)

(External API) Set concurrency level per QEngine shard

◆ set_qneuron_activation_fn()

MICROSOFT_QUANTUM_DECL void set_qneuron_activation_fn	(	_In_ uintq	nid,
		_In_ uintq	f
	)

◆ set_qneuron_alpha()

MICROSOFT_QUANTUM_DECL void set_qneuron_alpha	(	_In_ uintq	nid,
		_In_ double	alpha
	)

◆ set_qneuron_angles()

MICROSOFT_QUANTUM_DECL void set_qneuron_angles	(	_In_ uintq	nid,
		_In_ float *	angles
	)

◆ SetReactiveSeparate()

MICROSOFT_QUANTUM_DECL void SetReactiveSeparate	(	_In_ uintq	sid,
		_In_ bool	irs
	)

◆ SetSdrp()

MICROSOFT_QUANTUM_DECL void SetSdrp	(	_In_ uintq	sid,
		_In_ double	sdrp
	)

◆ SetTInjection()

MICROSOFT_QUANTUM_DECL void SetTInjection	(	_In_ uintq	sid,
		_In_ bool	irs
	)

◆ SUB()

MICROSOFT_QUANTUM_DECL void SUB	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q
	)

◆ SUBS()

MICROSOFT_QUANTUM_DECL void SUBS	(	_In_ uintq	sid,
		_In_ uintq	na,
		_In_reads_(na) uintq *	a,
		uintq	s,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q
	)

◆ SWAP()

MICROSOFT_QUANTUM_DECL void SWAP	(	_In_ uintq	sid,
		_In_ uintq	qi1,
		_In_ uintq	qi2
	)

◆ SwapShardValues()

void SwapShardValues	(	bitLenInt	v1,
		bitLenInt	v2,
		std::map< uintq, bitLenInt > &	simMap
	)

◆ T()

MICROSOFT_QUANTUM_DECL void T	(	_In_ uintq	sid,
		_In_ uintq	q
	)

(External API) "T" Gate

◆ TransformPauliBasis()

void TransformPauliBasis	(	QInterfacePtr	simulator,
		uintq	len,
		int *	bases,
		uintq *	qubitIds
	)

◆ TrySeparate1Qb()

MICROSOFT_QUANTUM_DECL bool TrySeparate1Qb	(	_In_ uintq	sid,
		_In_ uintq	qi1
	)

◆ TrySeparate2Qb()

MICROSOFT_QUANTUM_DECL bool TrySeparate2Qb	(	_In_ uintq	sid,
		_In_ uintq	qi1,
		_In_ uintq	qi2
	)

◆ TrySeparateTol()

MICROSOFT_QUANTUM_DECL bool TrySeparateTol	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_ double	tol
	)

◆ 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

◆ UCMtrx()

MICROSOFT_QUANTUM_DECL void UCMtrx	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	c,
		_In_reads_(8) double *	m,
		_In_ uintq	q,
		_In_ uintq	p
	)

(External API) Controlled 2x2 complex matrix unitary gate with arbitrary control permutation

◆ X()

MICROSOFT_QUANTUM_DECL void X	(	_In_ uintq	sid,
		_In_ uintq	q
	)

(External API) "X" Gate

◆ XNOR()

MICROSOFT_QUANTUM_DECL void XNOR	(	_In_ uintq	sid,
		_In_ uintq	qi1,
		_In_ uintq	qi2,
		_In_ uintq	qo
	)

◆ XOR()

MICROSOFT_QUANTUM_DECL void XOR	(	_In_ uintq	sid,
		_In_ uintq	qi1,
		_In_ uintq	qi2,
		_In_ uintq	qo
	)

◆ Y()

MICROSOFT_QUANTUM_DECL void Y	(	_In_ uintq	sid,
		_In_ uintq	q
	)

(External API) "Y" Gate

◆ Z()

MICROSOFT_QUANTUM_DECL void Z	(	_In_ uintq	sid,
		_In_ uintq	q
	)

(External API) "Z" Gate

Variable Documentation

◆ _maxShardQubits

bitLenInt _maxShardQubits = 0U

◆ circuitMutexes

std::map<QCircuit*, std::mutex> circuitMutexes

◆ circuitReservations

std::vector<bool> circuitReservations

◆ circuits

std::vector<QCircuitPtr> circuits

◆ metaError

int metaError = 0

◆ metaOperationMutex

std::mutex metaOperationMutex

◆ neuronErrors

std::vector<int> neuronErrors

◆ neuronMutexes

std::map<QNeuron*, std::mutex> neuronMutexes

◆ neuronReservations

std::vector<bool> neuronReservations

◆ neurons

std::vector<QNeuronPtr> neurons

◆ neuronSimulators

std::map<QNeuronPtr, QInterface*> neuronSimulators

◆ randNumGen

qrack_rand_gen_ptr randNumGen = std::make_shared<qrack_rand_gen>(time(0))

◆ shards

std::map<QInterface*, std::map<uintq, bitLenInt> > shards

◆ simulatorErrors

std::vector<int> simulatorErrors

◆ simulatorHostPointer

std::vector<bool> simulatorHostPointer

◆ simulatorMutexes

std::map<QInterface*, std::mutex> simulatorMutexes

◆ simulatorReservations

std::vector<bool> simulatorReservations

◆ simulators

std::vector<QInterfacePtr> simulators

◆ simulatorTypes

std::vector<std::vector<QInterfaceEngine> > simulatorTypes

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ CIRCUIT_AND_SIMULATOR_LOCK_GUARD_VOID

◆ CIRCUIT_LOCK_GUARD

◆ CIRCUIT_LOCK_GUARD_INT

◆ CIRCUIT_LOCK_GUARD_TYPED

◆ CIRCUIT_LOCK_GUARD_VOID

◆ MAP_CONTROLS_AND_LOCK

◆ MAP_MASK_AND_LOCK

◆ META_LOCK_GUARD

◆ NEURON_LOCK_GUARD

◆ NEURON_LOCK_GUARD_DOUBLE

◆ NEURON_LOCK_GUARD_INT

◆ NEURON_LOCK_GUARD_TYPED

◆ NEURON_LOCK_GUARD_VOID

◆ QALU

◆ QPARITY

◆ SIMULATOR_LOCK_GUARD

◆ SIMULATOR_LOCK_GUARD_BOOL

◆ SIMULATOR_LOCK_GUARD_DOUBLE

◆ SIMULATOR_LOCK_GUARD_INT

◆ SIMULATOR_LOCK_GUARD_TYPED

◆ SIMULATOR_LOCK_GUARD_VOID

Function Documentation

◆ _combineA()

◆ _darray_to_creal1_array()

◆ _FactorizedExpectation()

◆ _init_qcircuit_copy()

◆ _JointEnsembleProbabilityHelper()

◆ _PermutationExpectation()

◆ _PermutationProb()

◆ _Prob()

◆ ACSWAP()

◆ ADC()

◆ ADD()

◆ ADDS()

◆ AdjISWAP()

◆ AdjS()

◆ AdjT()

◆ allocateQubit()

◆ AND()

◆ CLAND()

◆ CLNAND()

◆ CLNOR()

◆ clone_qneuron()

◆ CLOR()

◆ CLXNOR()

◆ CLXOR()

◆ Compose()

◆ CSWAP()

◆ Decompose()

◆ destroy()

◆ destroy_qcircuit()

◆ destroy_qneuron()

◆ Dispose()

◆ DIV()

◆ DIVN()

◆ Dump()

◆ DumpIds()

◆ Exp()

◆ FactorizedExpectation()

◆ FactorizedExpectationFp()

◆ FactorizedExpectationFpRdm()

◆ FactorizedExpectationRdm()

◆ FindShardValue()

◆ ForceM()

◆ FSim()

◆ get_error()

◆ get_qcircuit_qubit_count()

◆ get_qneuron_activation_fn()

◆ get_qneuron_alpha()

◆ get_qneuron_angles()

◆ GetUnitaryFidelity()

◆ H()

◆ Hash()

◆ init_clone()

◆ init_count()