QuEST_cpu_local.c File Reference

#include "QuEST.h"
#include "QuEST_internal.h"
#include "QuEST_precision.h"
#include "mt19937ar.h"
#include "QuEST_cpu_internal.h"
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <sys/types.h>

Go to the source code of this file.

Functions
QuESTEnv	createQuESTEnv (void)
	Create the QuEST execution environment. More...
void	densmatr_applyDiagonalOp (Qureg qureg, DiagonalOp op)
Complex	densmatr_calcExpecDiagonalOp (Qureg qureg, DiagonalOp op)
qreal	densmatr_calcFidelity (Qureg qureg, Qureg pureState)
qreal	densmatr_calcHilbertSchmidtDistance (Qureg a, Qureg b)
qreal	densmatr_calcInnerProduct (Qureg a, Qureg b)
void	densmatr_calcProbOfAllOutcomes (qreal *retProbs, Qureg qureg, int *qubits, int numQubits)
qreal	densmatr_calcProbOfOutcome (Qureg qureg, int measureQubit, int outcome)
qreal	densmatr_calcPurity (Qureg qureg)
qreal	densmatr_calcTotalProb (Qureg qureg)
void	densmatr_initPureState (Qureg qureg, Qureg pureState)
void	densmatr_mixDamping (Qureg qureg, int targetQubit, qreal damping)
void	densmatr_mixDepolarising (Qureg qureg, int targetQubit, qreal depolLevel)
void	densmatr_mixTwoQubitDepolarising (Qureg qureg, int qubit1, int qubit2, qreal depolLevel)
void	destroyQuESTEnv (QuESTEnv env)
	Destroy the QuEST environment. More...
void	getEnvironmentString (QuESTEnv env, char str[200])
	Sets str to a string containing information about the runtime environment, including whether simulation is using CUDA (for GPU), OpenMP (for multithreading) and/or MPI (for distribution). More...
void	reportQuESTEnv (QuESTEnv env)
	Report information about the QuEST environment. More...
void	seedQuEST (QuESTEnv *env, unsigned long int *seedArray, int numSeeds)
	Seeds the random number generator with a custom array of key(s), overriding the default keys. More...
Complex	statevec_calcExpecDiagonalOp (Qureg qureg, DiagonalOp op)
Complex	statevec_calcInnerProduct (Qureg bra, Qureg ket)
void	statevec_calcProbOfAllOutcomes (qreal *retProbs, Qureg qureg, int *qubits, int numQubits)
qreal	statevec_calcProbOfOutcome (Qureg qureg, int measureQubit, int outcome)
qreal	statevec_calcTotalProb (Qureg qureg)
void	statevec_collapseToKnownProbOutcome (Qureg qureg, int measureQubit, int outcome, qreal stateProb)
void	statevec_compactUnitary (Qureg qureg, int targetQubit, Complex alpha, Complex beta)
void	statevec_controlledCompactUnitary (Qureg qureg, int controlQubit, int targetQubit, Complex alpha, Complex beta)
void	statevec_controlledNot (Qureg qureg, int controlQubit, int targetQubit)
void	statevec_controlledPauliY (Qureg qureg, int controlQubit, int targetQubit)
void	statevec_controlledPauliYConj (Qureg qureg, int controlQubit, int targetQubit)
void	statevec_controlledUnitary (Qureg qureg, int controlQubit, int targetQubit, ComplexMatrix2 u)
qreal	statevec_getImagAmp (Qureg qureg, long long int index)
qreal	statevec_getRealAmp (Qureg qureg, long long int index)
void	statevec_hadamard (Qureg qureg, int targetQubit)
void	statevec_multiControlledMultiQubitNot (Qureg qureg, int ctrlMask, int targMask)
void	statevec_multiControlledMultiQubitUnitary (Qureg qureg, long long int ctrlMask, int *targs, int numTargs, ComplexMatrixN u)
	This calls swapQubitAmps only when it would involve a distributed communication; if the qubit chunks already fit in the node, it operates the unitary direct. More...
void	statevec_multiControlledTwoQubitUnitary (Qureg qureg, long long int ctrlMask, int q1, int q2, ComplexMatrix4 u)
	This calls swapQubitAmps only when it would involve a distributed communication; if the qubit chunks already fit in the node, it operates the unitary direct. More...
void	statevec_multiControlledUnitary (Qureg qureg, long long int ctrlQubitsMask, long long int ctrlFlipMask, int targetQubit, ComplexMatrix2 u)
void	statevec_pauliX (Qureg qureg, int targetQubit)
void	statevec_pauliY (Qureg qureg, int targetQubit)
void	statevec_pauliYConj (Qureg qureg, int targetQubit)
void	statevec_swapQubitAmps (Qureg qureg, int qb1, int qb2)
void	statevec_unitary (Qureg qureg, int targetQubit, ComplexMatrix2 u)
void	syncQuESTEnv (QuESTEnv env)
	Guarantees that all code up to the given point has been executed on all nodes (if running in distributed mode) More...
int	syncQuESTSuccess (int successCode)
	Performs a logical AND on all successCodes held by all processes. More...

Detailed Description

An implementation of the pure backend in ../QuEST_ops_pure.h for a local (non-MPI, non-GPU) environment. Mostly pure-state wrappers for the local/distributed functions implemented in QuEST_cpu

Author

Ania Brown

Tyson Jones

Balint Koczor

Definition in file QuEST_cpu_local.c.

Function Documentation

densmatr_applyDiagonalOp()

void densmatr_applyDiagonalOp	(	Qureg	qureg,
		DiagonalOp	op
	)

Definition at line 358 of file QuEST_cpu_local.c.

                                                          {
 
    // we must preload qureg.pairStateVec with the elements of op.
    // instead of needless cloning, we'll just temporarily swap the pointers
    qreal* rePtr = qureg.pairStateVec.real;
    qreal* imPtr = qureg.pairStateVec.imag;
    qureg.pairStateVec.real = op.real;
    qureg.pairStateVec.imag = op.imag;
    
    densmatr_applyDiagonalOpLocal(qureg, op);
    
    qureg.pairStateVec.real = rePtr;
    qureg.pairStateVec.imag = imPtr;
}

References densmatr_applyDiagonalOpLocal(), DiagonalOp::imag, Qureg::pairStateVec, qreal, and DiagonalOp::real.

densmatr_calcExpecDiagonalOp()

Complex densmatr_calcExpecDiagonalOp	(	Qureg	qureg,
		DiagonalOp	op
	)

Definition at line 378 of file QuEST_cpu_local.c.

                                                                 {
    
    return densmatr_calcExpecDiagonalOpLocal(qureg, op);
}

References densmatr_calcExpecDiagonalOpLocal().

densmatr_calcFidelity()

qreal densmatr_calcFidelity	(	Qureg	qureg,
		Qureg	pureState
	)

Definition at line 75 of file QuEST_cpu_local.c.

                                                          {
    
    // save pointers to qureg's pair state
    qreal* quregPairRePtr = qureg.pairStateVec.real;
    qreal* quregPairImPtr = qureg.pairStateVec.imag;
    
    // populate qureg pair state with pure state (by repointing)
    qureg.pairStateVec.real = pureState.stateVec.real;
    qureg.pairStateVec.imag = pureState.stateVec.imag;
    
    // calculate fidelity using pairState
    qreal fid = densmatr_calcFidelityLocal(qureg, pureState);
    
    // restore pointers
    qureg.pairStateVec.real = quregPairRePtr;
    qureg.pairStateVec.imag = quregPairImPtr;
    
    return fid;
}

References densmatr_calcFidelityLocal(), Qureg::pairStateVec, qreal, and Qureg::stateVec.

densmatr_calcHilbertSchmidtDistance()

qreal densmatr_calcHilbertSchmidtDistance	(	Qureg	a,
		Qureg	b
	)

Definition at line 62 of file QuEST_cpu_local.c.

                                                            {
    
    qreal distSquared = densmatr_calcHilbertSchmidtDistanceSquaredLocal(a, b);
    qreal dist = sqrt(distSquared);
    return dist;
}

References densmatr_calcHilbertSchmidtDistanceSquaredLocal(), and qreal.

densmatr_calcInnerProduct()

qreal densmatr_calcInnerProduct	(	Qureg	a,
		Qureg	b
	)

Definition at line 69 of file QuEST_cpu_local.c.

                                                  {
    
    qreal scalar = densmatr_calcInnerProductLocal(a, b);
    return scalar;
}

References densmatr_calcInnerProductLocal(), and qreal.

densmatr_calcProbOfAllOutcomes()

void densmatr_calcProbOfAllOutcomes	(	qreal *	retProbs,
		Qureg	qureg,
		int *	qubits,
		int	numQubits
	)

Definition at line 317 of file QuEST_cpu_local.c.

                                                                                              {
    
    densmatr_calcProbOfAllOutcomesLocal(retProbs, qureg, qubits, numQubits);
}

References densmatr_calcProbOfAllOutcomesLocal().

densmatr_calcProbOfOutcome()

qreal densmatr_calcProbOfOutcome	(	Qureg	qureg,
		int	measureQubit,
		int	outcome
	)

Definition at line 304 of file QuEST_cpu_local.c.

                                                                             {
    
    qreal outcomeProb = densmatr_findProbabilityOfZeroLocal(qureg, measureQubit);
    if (outcome == 1)
        outcomeProb = 1.0 - outcomeProb;
    return outcomeProb;
}

References densmatr_findProbabilityOfZeroLocal(), and qreal.

densmatr_calcPurity()

qreal densmatr_calcPurity

(

Qureg

qureg

)

Definition at line 57 of file QuEST_cpu_local.c.

                                       {
    
    return densmatr_calcPurityLocal(qureg);
}

References densmatr_calcPurityLocal().

densmatr_calcTotalProb()

qreal densmatr_calcTotalProb

(

Qureg

qureg

)

Definition at line 118 of file QuEST_cpu_local.c.

                                          {
    
    // computes the trace using Kahan summation
    qreal pTotal=0;
    qreal y, t, c;
    c = 0;
    
    long long int numCols = 1LL << qureg.numQubitsRepresented;
    long long diagIndex;
    
    for (int col=0; col< numCols; col++) {
        diagIndex = col*(numCols + 1);
        y = qureg.stateVec.real[diagIndex] - c;
        t = pTotal + y;
        c = ( t - pTotal ) - y; // brackets are important
        pTotal = t;
    }
    
    // does not check imaginary component, by design
        
    return pTotal;
}

References Qureg::numQubitsRepresented, qreal, and Qureg::stateVec.

densmatr_initPureState()

void densmatr_initPureState	(	Qureg	qureg,
		Qureg	pureState
	)

Definition at line 95 of file QuEST_cpu_local.c.

                                                          {
    
    // save pointers to qureg's pair state
    qreal* quregPairRePtr = qureg.pairStateVec.real;
    qreal* quregPairImPtr = qureg.pairStateVec.imag;
    
    // populate qureg pair state with pure state (by repointing)
    qureg.pairStateVec.real = pureState.stateVec.real;
    qureg.pairStateVec.imag = pureState.stateVec.imag;
 
    // populate density matrix via it's pairState
    densmatr_initPureStateLocal(qureg, pureState);
    
    // restore pointers
    qureg.pairStateVec.real = quregPairRePtr;
    qureg.pairStateVec.imag = quregPairImPtr;
}

References densmatr_initPureStateLocal(), Qureg::pairStateVec, qreal, and Qureg::stateVec.

densmatr_mixDamping()

void densmatr_mixDamping	(	Qureg	qureg,
		int	targetQubit,
		qreal	damping
	)

Definition at line 37 of file QuEST_cpu_local.c.

                                                                      {
    if (damping == 0)
        return;
 
    densmatr_mixDampingLocal(qureg, targetQubit, damping);
}

References densmatr_mixDampingLocal().

densmatr_mixDepolarising()

void densmatr_mixDepolarising	(	Qureg	qureg,
		int	targetQubit,
		qreal	depolLevel
	)

Definition at line 30 of file QuEST_cpu_local.c.

                                                                              {
    if (depolLevel == 0)
        return;
 
    densmatr_mixDepolarisingLocal(qureg, targetQubit, depolLevel);
}

References densmatr_mixDepolarisingLocal().

densmatr_mixTwoQubitDepolarising()

void densmatr_mixTwoQubitDepolarising	(	Qureg	qureg,
		int	qubit1,
		int	qubit2,
		qreal	depolLevel
	)

Definition at line 44 of file QuEST_cpu_local.c.

                                                                                            {
    if (depolLevel == 0)
        return;
    qreal eta = 2/depolLevel;
    qreal delta = eta - 1 - sqrt( (eta-1)*(eta-1) - 1 );
    qreal gamma = 1+delta;
    // TODO -- test delta too small
 
    gamma = 1/(gamma*gamma*gamma);
    densmatr_mixTwoQubitDephasing(qureg, qubit1, qubit2, depolLevel);
    densmatr_mixTwoQubitDepolarisingLocal(qureg, qubit1, qubit2, delta, gamma);
}

References densmatr_mixTwoQubitDephasing(), densmatr_mixTwoQubitDepolarisingLocal(), and qreal.

statevec_calcExpecDiagonalOp()

Complex statevec_calcExpecDiagonalOp	(	Qureg	qureg,
		DiagonalOp	op
	)

Definition at line 373 of file QuEST_cpu_local.c.

                                                                 {
 
    return statevec_calcExpecDiagonalOpLocal(qureg, op);
}

References statevec_calcExpecDiagonalOpLocal().

statevec_calcInnerProduct()

Complex statevec_calcInnerProduct	(	Qureg	bra,
		Qureg	ket
	)

Definition at line 113 of file QuEST_cpu_local.c.

                                                        {
    
    return statevec_calcInnerProductLocal(bra, ket);
}

References statevec_calcInnerProductLocal().

statevec_calcProbOfAllOutcomes()

void statevec_calcProbOfAllOutcomes	(	qreal *	retProbs,
		Qureg	qureg,
		int *	qubits,
		int	numQubits
	)

Definition at line 312 of file QuEST_cpu_local.c.

                                                                                              {
    
    statevec_calcProbOfAllOutcomesLocal(retProbs, qureg, qubits, numQubits);
}

References statevec_calcProbOfAllOutcomesLocal().

statevec_calcProbOfOutcome()

qreal statevec_calcProbOfOutcome	(	Qureg	qureg,
		int	measureQubit,
		int	outcome
	)

Definition at line 296 of file QuEST_cpu_local.c.

{
    qreal outcomeProb = statevec_findProbabilityOfZeroLocal(qureg, measureQubit);
    if (outcome==1)
        outcomeProb = 1.0 - outcomeProb;
    return outcomeProb;
}

References qreal, and statevec_findProbabilityOfZeroLocal().

statevec_calcTotalProb()

qreal statevec_calcTotalProb

(

Qureg

qureg

)

Definition at line 141 of file QuEST_cpu_local.c.

                                         {
    // implemented using Kahan summation for greater accuracy at a slight floating
    // point operation overhead. For more details see https://en.wikipedia.org/wiki/Kahan_summation_algorithm
    qreal pTotal=0; 
    qreal y, t, c;
    long long int index;
    long long int numAmpsPerRank = qureg.numAmpsPerChunk;
    c = 0.0;
    for (index=0; index<numAmpsPerRank; index++){ 
        // Perform pTotal+=qureg.stateVec.real[index]*qureg.stateVec.real[index]; by Kahan
 
        y = qureg.stateVec.real[index]*qureg.stateVec.real[index] - c;
        t = pTotal + y;
        // Don't change the bracketing on the following line
        c = ( t - pTotal ) - y;
        pTotal = t;
 
        // Perform pTotal+=qureg.stateVec.imag[index]*qureg.stateVec.imag[index]; by Kahan
 
        y = qureg.stateVec.imag[index]*qureg.stateVec.imag[index] - c;
        t = pTotal + y;
        // Don't change the bracketing on the following line
        c = ( t - pTotal ) - y;
        pTotal = t;
    } 
    return pTotal;
}

References Qureg::numAmpsPerChunk, qreal, and Qureg::stateVec.

statevec_collapseToKnownProbOutcome()

void statevec_collapseToKnownProbOutcome	(	Qureg	qureg,
		int	measureQubit,
		int	outcome,
		qreal	stateProb
	)

Definition at line 322 of file QuEST_cpu_local.c.

{
    statevec_collapseToKnownProbOutcomeLocal(qureg, measureQubit, outcome, stateProb);
}

References statevec_collapseToKnownProbOutcomeLocal().

statevec_compactUnitary()

void statevec_compactUnitary	(	Qureg	qureg,
		int	targetQubit,
		Complex	alpha,
		Complex	beta
	)

Definition at line 227 of file QuEST_cpu_local.c.

{
    statevec_compactUnitaryLocal(qureg, targetQubit, alpha, beta);
}

References statevec_compactUnitaryLocal().

statevec_controlledCompactUnitary()

void statevec_controlledCompactUnitary	(	Qureg	qureg,
		int	controlQubit,
		int	targetQubit,
		Complex	alpha,
		Complex	beta
	)

Definition at line 237 of file QuEST_cpu_local.c.

{
    statevec_controlledCompactUnitaryLocal(qureg, controlQubit, targetQubit, alpha, beta);
}

References statevec_controlledCompactUnitaryLocal().

statevec_controlledNot()

void statevec_controlledNot	(	Qureg	qureg,
		int	controlQubit,
		int	targetQubit
	)

Definition at line 286 of file QuEST_cpu_local.c.

{
    statevec_controlledNotLocal(qureg, controlQubit, targetQubit);
}

References statevec_controlledNotLocal().

statevec_controlledPauliY()

void statevec_controlledPauliY	(	Qureg	qureg,
		int	controlQubit,
		int	targetQubit
	)

Definition at line 269 of file QuEST_cpu_local.c.

{
    int conjFac = 1;
    statevec_controlledPauliYLocal(qureg, controlQubit, targetQubit, conjFac);
}

References statevec_controlledPauliYLocal().

statevec_controlledPauliYConj()

void statevec_controlledPauliYConj	(	Qureg	qureg,
		int	controlQubit,
		int	targetQubit
	)

Definition at line 275 of file QuEST_cpu_local.c.

{
    int conjFac = -1;
    statevec_controlledPauliYLocal(qureg, controlQubit, targetQubit, conjFac);
}

References statevec_controlledPauliYLocal().

statevec_controlledUnitary()

void statevec_controlledUnitary	(	Qureg	qureg,
		int	controlQubit,
		int	targetQubit,
		ComplexMatrix2	u
	)

Definition at line 242 of file QuEST_cpu_local.c.

{
    statevec_controlledUnitaryLocal(qureg, controlQubit, targetQubit, u);
}

References statevec_controlledUnitaryLocal().

statevec_getImagAmp()

qreal statevec_getImagAmp	(	Qureg	qureg,
		long long int	index
	)

Definition at line 223 of file QuEST_cpu_local.c.

                                                           {
    return qureg.stateVec.imag[index];
}

References Qureg::stateVec.

statevec_getRealAmp()

qreal statevec_getRealAmp	(	Qureg	qureg,
		long long int	index
	)

Definition at line 219 of file QuEST_cpu_local.c.

                                                           {
    return qureg.stateVec.real[index];
}

References Qureg::stateVec.

statevec_hadamard()

void statevec_hadamard	(	Qureg	qureg,
		int	targetQubit
	)

Definition at line 281 of file QuEST_cpu_local.c.

{
    statevec_hadamardLocal(qureg, targetQubit);
}

References statevec_hadamardLocal().

statevec_multiControlledMultiQubitNot()

void statevec_multiControlledMultiQubitNot	(	Qureg	qureg,
		int	ctrlMask,
		int	targMask
	)

Definition at line 291 of file QuEST_cpu_local.c.

                                                                                    {
    
    statevec_multiControlledMultiQubitNotLocal(qureg, ctrlMask, targMask);
}

References statevec_multiControlledMultiQubitNotLocal().

statevec_multiControlledMultiQubitUnitary()

void statevec_multiControlledMultiQubitUnitary	(	Qureg	qureg,
		long long int	ctrlMask,
		int *	targs,
		int	numTargs,
		ComplexMatrixN	u
	)

This calls swapQubitAmps only when it would involve a distributed communication; if the qubit chunks already fit in the node, it operates the unitary direct.

It is already gauranteed here that all target qubits can fit on each node (this is validated in the front-end)

Todo:

refactor so that the 'swap back' isn't performed; instead the qubit locations are updated.

Definition at line 348 of file QuEST_cpu_local.c.

{
    statevec_multiControlledMultiQubitUnitaryLocal(qureg, ctrlMask, targs, numTargs, u);
}

References statevec_multiControlledMultiQubitUnitaryLocal().

statevec_multiControlledTwoQubitUnitary()

void statevec_multiControlledTwoQubitUnitary	(	Qureg	qureg,
		long long int	ctrlMask,
		int	q1,
		int	q2,
		ComplexMatrix4	u
	)

This calls swapQubitAmps only when it would involve a distributed communication; if the qubit chunks already fit in the node, it operates the unitary direct.

Note the order of q1 and q2 in the call to twoQubitUnitaryLocal is important.

Todo:

refactor so that the 'swap back' isn't performed; instead the qubit locations are updated.

the double swap (q1,q2 to 0,1) may be possible simultaneously by a bespoke swap routine.

Definition at line 343 of file QuEST_cpu_local.c.

{
    statevec_multiControlledTwoQubitUnitaryLocal(qureg, ctrlMask, q1, q2, u);
}

References statevec_multiControlledTwoQubitUnitaryLocal().

statevec_multiControlledUnitary()

void statevec_multiControlledUnitary	(	Qureg	qureg,
		long long int	ctrlQubitsMask,
		long long int	ctrlFlipMask,
		int	targetQubit,
		ComplexMatrix2	u
	)

Definition at line 247 of file QuEST_cpu_local.c.

{
    statevec_multiControlledUnitaryLocal(qureg, targetQubit, ctrlQubitsMask, ctrlFlipMask, u);
}

References statevec_multiControlledUnitaryLocal().

statevec_pauliX()

void statevec_pauliX	(	Qureg	qureg,
		int	targetQubit
	)

Definition at line 252 of file QuEST_cpu_local.c.

{
    statevec_pauliXLocal(qureg, targetQubit);
}

References statevec_pauliXLocal().

statevec_pauliY()

void statevec_pauliY	(	Qureg	qureg,
		int	targetQubit
	)

Definition at line 257 of file QuEST_cpu_local.c.

{
    int conjFac = 1;
    statevec_pauliYLocal(qureg, targetQubit, conjFac);
}

References statevec_pauliYLocal().

statevec_pauliYConj()

void statevec_pauliYConj	(	Qureg	qureg,
		int	targetQubit
	)

Definition at line 263 of file QuEST_cpu_local.c.

{
    int conjFac = -1;
    statevec_pauliYLocal(qureg, targetQubit, conjFac);
}

References statevec_pauliYLocal().

statevec_swapQubitAmps()

void statevec_swapQubitAmps	(	Qureg	qureg,
		int	qb1,
		int	qb2
	)

Definition at line 353 of file QuEST_cpu_local.c.

{
    statevec_swapQubitAmpsLocal(qureg, qb1, qb2);
}

References statevec_swapQubitAmpsLocal().

statevec_unitary()

void statevec_unitary	(	Qureg	qureg,
		int	targetQubit,
		ComplexMatrix2	u
	)

Definition at line 232 of file QuEST_cpu_local.c.

{
    statevec_unitaryLocal(qureg, targetQubit, u);
}

References statevec_unitaryLocal().