pinvoke_api.cpp File Reference

#include "pinvoke_api.hpp"
#include "qcircuit.hpp"
#include "qneuron.hpp"
#include "qfactory.hpp"
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <mutex>
#include <numeric>
#include <sstream>
#include <string>

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_ONLY_LOCK_GUARD(neuron)
#define	NEURON_LOCK_GUARD(neuron)
#define	NEURON_LOCK_GUARD_VOID(nid)
#define	NEURON_ONLY_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	GetSimShardId (QInterfacePtr simulator, bitLenInt i)
void	FillSimShards (QInterfacePtr simulator)
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 nw, _In_ bool hy, _In_ bool oc, _In_ bool hp, _In_ bool sp)
	(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, _In_ bool sp)
	(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, _In_ bool sp)
	(External API) Initialize a simulator ID with "q" qubits and implicit default layer options. More...
MICROSOFT_QUANTUM_DECL uintq	init_count_stabilizer (_In_ uintq q)
	(External API) Initialize a simulator ID with "q" qubits as purely a stabilizer simulator. More...
MICROSOFT_QUANTUM_DECL uintq	init_clone (_In_ uintq sid)
	(External API) Initialize a simulator ID that clones simulator ID "sid" More...
uintq	init_clone_size (uintq sid, uintq n)
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	set_device (_In_ uintq sid, _In_ intq did)
	(External API) Set GPU device ID on the simulator. More...
MICROSOFT_QUANTUM_DECL void	set_device_list (_In_ uintq sid, _In_ uintq n, _In_reads_(n) intq *dids)
	(External API) Set GPU device IDs on the simulator. 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_s *ket)
	(External API) Set state vector for the selected simulator ID. More...
MICROSOFT_QUANTUM_DECL void	OutKet (_In_ uintq sid, _In_ real1_s *ket)
	(External API) Get state vector for the selected simulator ID. More...
MICROSOFT_QUANTUM_DECL void	OutReducedDensityMatrix (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, real1_s *rdm)
	(External API) Get reduced density matrix for the selected simulator ID and qubits. More...
MICROSOFT_QUANTUM_DECL void	OutProbs (_In_ uintq sid, _In_ real1_s *probs)
	(External API) Get basis dimension probabilities 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...
void	_PhaseMask (uintq sid, double lambda, uintq p, uintq n, uintq *q, bool isParity)
MICROSOFT_QUANTUM_DECL void	PhaseParity (_In_ uintq sid, _In_ double lambda, _In_ uintq n, _In_reads_(n) uintq *q)
MICROSOFT_QUANTUM_DECL void	PhaseRootN (_In_ uintq sid, _In_ uintq p, _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	SX (_In_ uintq sid, _In_ uintq q)
	(External API) Square root of X gate More...
MICROSOFT_QUANTUM_DECL void	SY (_In_ uintq sid, _In_ uintq q)
	(External API) Square root of Y 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	AdjSX (_In_ uintq sid, _In_ uintq q)
	(External API) Inverse square root of X gate More...
MICROSOFT_QUANTUM_DECL void	AdjSY (_In_ uintq sid, _In_ uintq q)
	(External API) Inverse square root of Y 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, DEPRECATED) 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 void	MAllLong (_In_ uintq sid, uintq *r)
	(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)
MICROSOFT_QUANTUM_DECL void	HighestProbAll (_In_ uintq sid, uintq *r)
	(External API) Get the permutation with the highest probability More...
MICROSOFT_QUANTUM_DECL void	HighestProbAllN (_In_ uintq sid, _In_ uintq n, uintq *r)
	(External API) Get the top n permutations with the highest probability More...
double	_Prob (_In_ uintq sid, _In_ uintq q, bool isRdm)
MICROSOFT_QUANTUM_DECL void	ProbAll (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, real1_s *p)
	(External API) Get the probabilities of all permutations of the requested subset of qubits. More...
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	_PermutationExpVar (uintq sid, uintq n, uintq *q, bool r, bool isRdm, bool isExp)
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...
MICROSOFT_QUANTUM_DECL double	Variance (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q)
	(External API) Get the permutation variance, based upon the order of input qubits. More...
MICROSOFT_QUANTUM_DECL double	VarianceRdm (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, bool r)
	(External API) Get the permutation variance based upon the order of input qubits, treating all ancillary qubits as post-selected T gate gadgets. More...
double	_FactorizedExpVar (uintq sid, uintq n, uintq *q, uintq m, uintq *c, real1_s *f, bool r, bool isRdm, bool isExp)
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	FactorizedVariance (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_ uintq m, uintq *c)
	(External API) Get the permutation variance, based upon the order of input qubits. More...
MICROSOFT_QUANTUM_DECL double	FactorizedVarianceRdm (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_ uintq m, uintq *c, _In_ bool r)
	(External API) Get the permutation variance, 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_s *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_s *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	FactorizedVarianceFp (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, real1_s *c)
	(External API) Get the permutation variance, based upon the order of input qubits. More...
MICROSOFT_QUANTUM_DECL double	FactorizedVarianceFpRdm (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, real1_s *c, _In_ bool r)
	(External API) Get the permutation variance, based upon the order of input qubits, treating all ancillary qubits as post-selected T gate gadgets. More...
double	UnitaryExpVar (bool isExp, uintq sid, uintq n, uintq *q, real1_s *b)
MICROSOFT_QUANTUM_DECL double	UnitaryExpectation (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_reads_(3 *n) real1_s *b)
	(External API) Get the single-qubit (3-parameter) operator expectation value for the array of qubits and bases. More...
MICROSOFT_QUANTUM_DECL double	UnitaryVariance (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_reads_(3 *n) real1_s *b)
	(External API) Get the single-qubit (3-parameter) operator variance for the array of qubits and bases. More...
double	MatrixExpVar (bool isExp, uintq sid, uintq n, uintq *q, real1_s *b)
MICROSOFT_QUANTUM_DECL double	MatrixExpectation (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_reads_(8 *n) real1_s *b)
	(External API) Get the single-qubit (2x2) operator expectation value for the array of qubits and bases. More...
MICROSOFT_QUANTUM_DECL double	MatrixVariance (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_reads_(8 *n) real1_s *b)
	(External API) Get the single-qubit (2x2) operator variance for the array of qubits and bases. More...
double	UnitaryExpVarEigenVal (bool isExp, uintq sid, uintq n, uintq *q, real1_s *b, real1_s *e)
MICROSOFT_QUANTUM_DECL double	UnitaryExpectationEigenVal (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_reads_(3 *n) real1_s *b, _In_reads_(2 *n) real1_s *e)
	(External API) Get the single-qubit (3-parameter) operator expectation value for the array of qubits and bases. More...
MICROSOFT_QUANTUM_DECL double	UnitaryVarianceEigenVal (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_reads_(3 *n) real1_s *b, _In_reads_(2 *n) real1_s *e)
	(External API) Get the single-qubit (3-parameter) operator variance for the array of qubits and bases. More...
double	MatrixExpVarEigenVal (bool isExp, uintq sid, uintq n, uintq *q, real1_s *b, real1_s *e)
MICROSOFT_QUANTUM_DECL double	MatrixExpectationEigenVal (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_reads_(8 *n) real1_s *b, _In_reads_(2 *n) real1_s *e)
	(External API) Get the single-qubit (2x2) operator expectation value for the array of qubits and bases. More...
MICROSOFT_QUANTUM_DECL double	MatrixVarianceEigenVal (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_reads_(8 *n) real1_s *b, _In_reads_(2 *n) real1_s *e)
	(External API) Get the single-qubit (2x2) operator variance for the array of qubits and bases. More...
double	PauliExpVar (bool isExp, uintq sid, uintq n, uintq *q, uintq *b)
MICROSOFT_QUANTUM_DECL double	PauliExpectation (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_reads_(n) uintq *b)
	(External API) Get the Pauli operator expectation value for the array of qubits and bases. More...
MICROSOFT_QUANTUM_DECL double	PauliVariance (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q, _In_reads_(n) uintq *b)
	(External API) Get the Pauli operator variance for the array of qubits and bases. 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 void	Separate (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *q)
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	SetNcrp (_In_ uintq sid, _In_ double ncrp)
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 void	SetNoiseParameter (_In_ uintq sid, _In_ double np)
MICROSOFT_QUANTUM_DECL void	SetAceMaxQb (_In_ uintq sid, _In_ uintq qb)
MICROSOFT_QUANTUM_DECL void	SetSparseAceMaxMb (_In_ uintq sid, _In_ size_t mb)
MICROSOFT_QUANTUM_DECL void	Normalize (_In_ uintq sid)
MICROSOFT_QUANTUM_DECL uintq	init_qneuron (_In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
MICROSOFT_QUANTUM_DECL uintq	clone_qneuron (_In_ uintq nid)
MICROSOFT_QUANTUM_DECL void	destroy_qneuron (_In_ uintq nid)
MICROSOFT_QUANTUM_DECL void	set_qneuron_sim (_In_ uintq nid, _In_ uintq sid, _In_ uintq n, _In_reads_(n) uintq *c, _In_ uintq q)
MICROSOFT_QUANTUM_DECL double	qneuron_predict (_In_ uintq nid, _In_ real1_s *angles, _In_ bool e, _In_ bool r, _In_ uintq f, _In_ double a)
MICROSOFT_QUANTUM_DECL double	qneuron_unpredict (_In_ uintq nid, _In_ real1_s *angles, _In_ bool e, _In_ uintq f, _In_ double a)
MICROSOFT_QUANTUM_DECL double	qneuron_learn_cycle (_In_ uintq nid, _In_ real1_s *angles, _In_ bool e, _In_ uintq f, _In_ double a)
MICROSOFT_QUANTUM_DECL void	qneuron_learn (_In_ uintq nid, _In_ real1_s *angles, _In_ double eta, _In_ bool e, _In_ bool r, _In_ uintq f, _In_ double a)
MICROSOFT_QUANTUM_DECL void	qneuron_learn_permutation (_In_ uintq nid, _In_ real1_s *angles, _In_ double eta, _In_ bool e, _In_ bool r, _In_ uintq f, _In_ double a)
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)
MICROSOFT_QUANTUM_DECL size_t	qcircuit_out_to_string_length (_In_ uintq cid)
MICROSOFT_QUANTUM_DECL void	qcircuit_out_to_string (_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::vector< bool >	simulatorSparse
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
std::map< QCircuit *, std::string >	circuitStrings

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] = GetSimShardId(simulator, c[i]);                                                                \
    }

MAP_MASK_AND_LOCK

#define MAP_MASK_AND_LOCK	(		sid,
			numQ
	)

Value:

    SIMULATOR_LOCK_GUARD_VOID(sid)                                                                                     \
    bitCapInt mask = ZERO_BCI;                                                                                         \
    for (uintq i = 0U; i < numQ; ++i) {                                                                                \
        bi_or_ip(&mask, pow2(GetSimShardId(simulator, 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;                                                                                                        \
    }

NEURON_ONLY_LOCK_GUARD

#define NEURON_ONLY_LOCK_GUARD

(

neuron

)

Value:

    std::unique_ptr<const std::lock_guard<std::mutex>> neuronLock;                                                     \
    if (true) {                                                                                                        \
        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));                      \
    }

NEURON_ONLY_LOCK_GUARD_VOID

#define NEURON_ONLY_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_ONLY_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);CMPLX_DEFAULT_ARG, false, true, hp, -1, true, sp)                               \
        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
	)

_FactorizedExpVar()

double _FactorizedExpVar	(	uintq	sid,
		uintq	n,
		uintq *	q,
		uintq	m,
		uintq *	c,
		real1_s *	f,
		bool	r,
		bool	isRdm,
		bool	isExp
	)

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

_PermutationExpVar()

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

_PermutationProb()

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

_PhaseMask()

void _PhaseMask	(	uintq	sid,
		double	lambda,
		uintq	p,
		uintq	n,
		uintq *	q,
		bool	isParity
	)

_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

AdjSX()

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

(External API) Inverse square root of X gate

AdjSY()

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

(External API) Inverse square root of Y 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_s *	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_s *	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.

FactorizedVariance()

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

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

FactorizedVarianceFp()

MICROSOFT_QUANTUM_DECL double FactorizedVarianceFp	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		real1_s *	c
	)

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

FactorizedVarianceFpRdm()

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

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

FactorizedVarianceRdm()

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

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

FillSimShards()

void FillSimShards

(

QInterfacePtr

simulator

)

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

)

GetSimShardId()

bitLenInt GetSimShardId	(	QInterfacePtr	simulator,
		bitLenInt	i
	)

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
	)

HighestProbAll()

MICROSOFT_QUANTUM_DECL void HighestProbAll	(	_In_ uintq	sid,
		uintq *	r
	)

(External API) Get the permutation with the highest probability

HighestProbAllN()

MICROSOFT_QUANTUM_DECL void HighestProbAllN	(	_In_ uintq	sid,
		_In_ uintq	n,
		uintq *	r
	)

(External API) Get the top n permutations with the highest probability

init_clone()

MICROSOFT_QUANTUM_DECL uintq init_clone

(

_In_ uintq

sid

)

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

init_clone_size()

uintq init_clone_size	(	uintq	sid,
		uintq	n
	)

init_count()

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

(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,
		_In_ bool	sp
	)

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

init_count_stabilizer()

MICROSOFT_QUANTUM_DECL uintq init_count_stabilizer

(

_In_ uintq

q

)

(External API) Initialize a simulator ID with "q" qubits as purely a stabilizer simulator.

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	nw,
		_In_ bool	hy,
		_In_ bool	oc,
		_In_ bool	hp,
		_In_ bool	sp
	)

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

InKet()

MICROSOFT_QUANTUM_DECL void InKet	(	_In_ uintq	sid,
		_In_ real1_s *	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, DEPRECATED) 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.

MAllLong()

MICROSOFT_QUANTUM_DECL void MAllLong	(	_In_ uintq	sid,
		uintq *	r
	)

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

MatrixExpectation()

MICROSOFT_QUANTUM_DECL double MatrixExpectation	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(8 *n) real1_s *	b
	)

(External API) Get the single-qubit (2x2) operator expectation value for the array of qubits and bases.

MatrixExpectationEigenVal()

MICROSOFT_QUANTUM_DECL double MatrixExpectationEigenVal	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(8 *n) real1_s *	b,
		_In_reads_(2 *n) real1_s *	e
	)

(External API) Get the single-qubit (2x2) operator expectation value for the array of qubits and bases.

MatrixExpVar()

double MatrixExpVar	(	bool	isExp,
		uintq	sid,
		uintq	n,
		uintq *	q,
		real1_s *	b
	)

MatrixExpVarEigenVal()

double MatrixExpVarEigenVal	(	bool	isExp,
		uintq	sid,
		uintq	n,
		uintq *	q,
		real1_s *	b,
		real1_s *	e
	)

MatrixVariance()

MICROSOFT_QUANTUM_DECL double MatrixVariance	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(8 *n) real1_s *	b
	)

(External API) Get the single-qubit (2x2) operator variance for the array of qubits and bases.

MatrixVarianceEigenVal()

MICROSOFT_QUANTUM_DECL double MatrixVarianceEigenVal	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(8 *n) real1_s *	b,
		_In_reads_(2 *n) real1_s *	e
	)

(External API) Get the single-qubit (2x2) operator variance for the array of qubits and bases.

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
	)

Normalize()

MICROSOFT_QUANTUM_DECL void Normalize

(

_In_ uintq

sid

)

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_s *	ket
	)

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

OutProbs()

MICROSOFT_QUANTUM_DECL void OutProbs	(	_In_ uintq	sid,
		_In_ real1_s *	probs
	)

(External API) Get basis dimension probabilities for the selected simulator ID.

OutReducedDensityMatrix()

MICROSOFT_QUANTUM_DECL void OutReducedDensityMatrix	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		real1_s *	rdm
	)

(External API) Get reduced density matrix for the selected simulator ID and qubits.

PauliExpectation()

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

(External API) Get the Pauli operator expectation value for the array of qubits and bases.

PauliExpVar()

double PauliExpVar	(	bool	isExp,
		uintq	sid,
		uintq	n,
		uintq *	q,
		uintq *	b
	)

PauliVariance()

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

(External API) Get the Pauli operator variance for the array of qubits and bases.

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
	)

PhaseRootN()

MICROSOFT_QUANTUM_DECL void PhaseRootN	(	_In_ uintq	sid,
		_In_ uintq	p,
		_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.

ProbAll()

MICROSOFT_QUANTUM_DECL void ProbAll	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		real1_s *	p
	)

(External API) Get the probabilities of all permutations of the requested subset of qubits.

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_out_to_string()

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

qcircuit_out_to_string_length()

MICROSOFT_QUANTUM_DECL size_t qcircuit_out_to_string_length

(

_In_ uintq

cid

)

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_ real1_s *	angles,
		_In_ double	eta,
		_In_ bool	e,
		_In_ bool	r,
		_In_ uintq	f,
		_In_ double	a
	)

qneuron_learn_cycle()

MICROSOFT_QUANTUM_DECL double qneuron_learn_cycle	(	_In_ uintq	nid,
		_In_ real1_s *	angles,
		_In_ bool	e,
		_In_ uintq	f,
		_In_ double	a
	)

qneuron_learn_permutation()

MICROSOFT_QUANTUM_DECL void qneuron_learn_permutation	(	_In_ uintq	nid,
		_In_ real1_s *	angles,
		_In_ double	eta,
		_In_ bool	e,
		_In_ bool	r,
		_In_ uintq	f,
		_In_ double	a
	)

qneuron_predict()

MICROSOFT_QUANTUM_DECL double qneuron_predict	(	_In_ uintq	nid,
		_In_ real1_s *	angles,
		_In_ bool	e,
		_In_ bool	r,
		_In_ uintq	f,
		_In_ double	a
	)

qneuron_unpredict()

MICROSOFT_QUANTUM_DECL double qneuron_unpredict	(	_In_ uintq	nid,
		_In_ real1_s *	angles,
		_In_ bool	e,
		_In_ uintq	f,
		_In_ double	a
	)

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

Separate()

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

set_concurrency()

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

(External API) Set concurrency level per QEngine shard

set_device()

MICROSOFT_QUANTUM_DECL void set_device	(	_In_ uintq	sid,
		_In_ intq	did
	)

(External API) Set GPU device ID on the simulator.

set_device_list()

MICROSOFT_QUANTUM_DECL void set_device_list	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) intq *	dids
	)

(External API) Set GPU device IDs on the simulator.

set_qneuron_sim()

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

SetAceMaxQb()

MICROSOFT_QUANTUM_DECL void SetAceMaxQb	(	_In_ uintq	sid,
		_In_ uintq	qb
	)

SetNcrp()

MICROSOFT_QUANTUM_DECL void SetNcrp	(	_In_ uintq	sid,
		_In_ double	ncrp
	)

SetNoiseParameter()

MICROSOFT_QUANTUM_DECL void SetNoiseParameter	(	_In_ uintq	sid,
		_In_ double	np
	)

SetReactiveSeparate()

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

SetSdrp()

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

SetSparseAceMaxMb()

MICROSOFT_QUANTUM_DECL void SetSparseAceMaxMb	(	_In_ uintq	sid,
		_In_ size_t	mb
	)

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
	)

SX()

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

(External API) Square root of X gate

SY()

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

(External API) Square root of Y gate

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

UnitaryExpectation()

MICROSOFT_QUANTUM_DECL double UnitaryExpectation	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(3 *n) real1_s *	b
	)

(External API) Get the single-qubit (3-parameter) operator expectation value for the array of qubits and bases.

UnitaryExpectationEigenVal()

MICROSOFT_QUANTUM_DECL double UnitaryExpectationEigenVal	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(3 *n) real1_s *	b,
		_In_reads_(2 *n) real1_s *	e
	)

(External API) Get the single-qubit (3-parameter) operator expectation value for the array of qubits and bases.

UnitaryExpVar()

double UnitaryExpVar	(	bool	isExp,
		uintq	sid,
		uintq	n,
		uintq *	q,
		real1_s *	b
	)

UnitaryExpVarEigenVal()

double UnitaryExpVarEigenVal	(	bool	isExp,
		uintq	sid,
		uintq	n,
		uintq *	q,
		real1_s *	b,
		real1_s *	e
	)

UnitaryVariance()

MICROSOFT_QUANTUM_DECL double UnitaryVariance	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(3 *n) real1_s *	b
	)

(External API) Get the single-qubit (3-parameter) operator variance for the array of qubits and bases.

UnitaryVarianceEigenVal()

MICROSOFT_QUANTUM_DECL double UnitaryVarianceEigenVal	(	_In_ uintq	sid,
		_In_ uintq	n,
		_In_reads_(n) uintq *	q,
		_In_reads_(3 *n) real1_s *	b,
		_In_reads_(2 *n) real1_s *	e
	)

(External API) Get the single-qubit (3-parameter) operator variance for the array of qubits and bases.

Variance()

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

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

VarianceRdm()

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

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

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

circuitMutexes

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

circuitReservations

std::vector<bool> circuitReservations

circuits

std::vector<QCircuitPtr> circuits

circuitStrings

std::map<QCircuit*, std::string> circuitStrings

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

simulatorSparse

std::vector<bool> simulatorSparse

simulatorTypes

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