#include "QuEST.h"
#include "QuEST_precision.h"
#include "QuEST_internal.h"
#include "QuEST_qasm.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

Macros
#define	BUF_GROW_FAC 2

#define	BUF_INIT_SIZE 1024

#define	COMMENT_PREF "//"

#define	CTRL_LABEL_PREF "c"

#define	INIT_ZERO_CMD "reset"

#define	MAX_LINE_LEN 1024

#define	MAX_REG_SYMBS 24

#define	MEASURE_CMD "measure"

#define	MESREG_LABEL "c"

#define	QUREG_LABEL "q"
	TODO. More...

Functions
void	addGateToQASM (Qureg qureg, TargetGate gate, int controlQubits, int numControlQubits, int targetQubit, qreal params, int numParams)

void	addMultiVarOverridesToQASM (Qureg qureg, int numRegs, long long int overrideInds, qreal overridePhases, int numOverrides)

void	addMultiVarRegsToQASM (Qureg qureg, int qubits, int numQubitsPerReg, int numRegs, enum bitEncoding encoding)

void	addShiftValuesToQASM (Qureg qureg, enum phaseFunc funcName, int numRegs, qreal *params)

void	addStringToQASM (Qureg qureg, char line[], int lineLen)

void	bufferOverflow (void)

char	getPhaseFuncSymbol (int numSymbs, int ind)

void	qasm_clearRecorded (Qureg qureg)

void	qasm_free (Qureg qureg)

void	qasm_printRecorded (Qureg qureg)

void	qasm_recordAxisRotation (Qureg qureg, qreal angle, Vector axis, int targetQubit)

void	qasm_recordComment (Qureg qureg, char *comment,...)

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

void	qasm_recordControlledAxisRotation (Qureg qureg, qreal angle, Vector axis, int controlQubit, int targetQubit)

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

void	qasm_recordControlledGate (Qureg qureg, TargetGate gate, int controlQubit, int targetQubit)

void	qasm_recordControlledParamGate (Qureg qureg, TargetGate gate, int controlQubit, int targetQubit, qreal param)

void	qasm_recordControlledUnitary (Qureg qureg, ComplexMatrix2 u, int controlQubit, int targetQubit)
	additionally performs Rz on target to restore the global phase lost from u in QASM U(a,b,c) More...

void	qasm_recordGate (Qureg qureg, TargetGate gate, int targetQubit)

void	qasm_recordInitClassical (Qureg qureg, long long int stateInd)

void	qasm_recordInitPlus (Qureg qureg)

void	qasm_recordInitZero (Qureg qureg)

void	qasm_recordMeasurement (Qureg qureg, int measureQubit)

void	qasm_recordMultiControlledGate (Qureg qureg, TargetGate gate, int *controlQubits, int numControlQubits, int targetQubit)

void	qasm_recordMultiControlledMultiQubitNot (Qureg qureg, int ctrls, int numCtrls, int targs, int numTargs)

void	qasm_recordMultiControlledParamGate (Qureg qureg, TargetGate gate, int *controlQubits, int numControlQubits, int targetQubit, qreal param)

void	qasm_recordMultiControlledUnitary (Qureg qureg, ComplexMatrix2 u, int *controlQubits, int numControlQubits, int targetQubit)
	additionally performs Rz on target to restore the global phase lost from u in QASM U(a,b,c) More...

void	qasm_recordMultiStateControlledUnitary (Qureg qureg, ComplexMatrix2 u, int controlQubits, int controlState, int numControlQubits, int targetQubit)

void	qasm_recordMultiVarPhaseFunc (Qureg qureg, int qubits, int numQubitsPerReg, int numRegs, enum bitEncoding encoding, qreal coeffs, qreal exponents, int numTermsPerReg, long long int overrideInds, qreal *overridePhases, int numOverrides)

void	qasm_recordNamedPhaseFunc (Qureg qureg, int qubits, int numQubitsPerReg, int numRegs, enum bitEncoding encoding, enum phaseFunc funcName, qreal params, int numParams, long long int overrideInds, qreal *overridePhases, int numOverrides)

void	qasm_recordParamGate (Qureg qureg, TargetGate gate, int targetQubit, qreal param)

void	qasm_recordPhaseFunc (Qureg qureg, int qubits, int numQubits, enum bitEncoding encoding, qreal coeffs, qreal exponents, int numTerms, long long int overrideInds, qreal *overridePhases, int numOverrides)

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

void	qasm_setup (Qureg *qureg)

void	qasm_startRecording (Qureg qureg)

void	qasm_stopRecording (Qureg qureg)

int	qasm_writeRecordedToFile (Qureg qureg, char *filename)
	returns success of file write More...

Variables
static const char *	qasmGateLabels []

Detailed Description

Functions for generating QASM output from QuEST circuits

Author: Tyson Jones

Definition in file QuEST_qasm.c.

Macro Definition Documentation

◆ BUF_GROW_FAC

#define BUF_GROW_FAC 2

Definition at line 36 of file QuEST_qasm.c.

◆ BUF_INIT_SIZE

#define BUF_INIT_SIZE 1024

Definition at line 35 of file QuEST_qasm.c.

◆ COMMENT_PREF

#define COMMENT_PREF "//"

Definition at line 32 of file QuEST_qasm.c.

◆ CTRL_LABEL_PREF

#define CTRL_LABEL_PREF "c"

Definition at line 29 of file QuEST_qasm.c.

◆ INIT_ZERO_CMD

#define INIT_ZERO_CMD "reset"

Definition at line 31 of file QuEST_qasm.c.

◆ MAX_LINE_LEN

#define MAX_LINE_LEN 1024

Definition at line 34 of file QuEST_qasm.c.

◆ MAX_REG_SYMBS

#define MAX_REG_SYMBS 24

Definition at line 37 of file QuEST_qasm.c.

◆ MEASURE_CMD

#define MEASURE_CMD "measure"

Definition at line 30 of file QuEST_qasm.c.

◆ MESREG_LABEL

#define MESREG_LABEL "c"

Definition at line 28 of file QuEST_qasm.c.

◆ QUREG_LABEL

#define QUREG_LABEL "q"

TODO.

allow user-set decimal precision (useful for when QASM is passed to a plotter)
sort out fixing global phase in controlledPhaseShift to controlledRotateZ plug
add functions to directly add comments to QASM by user
add abilitiy for user to directly add strings to QASM buffer??

Definition at line 27 of file QuEST_qasm.c.

Function Documentation

◆ addGateToQASM()

void addGateToQASM	(	Qureg	qureg,
		TargetGate	gate,
		int *	controlQubits,
		int	numControlQubits,
		int	targetQubit,
		qreal *	params,
		int	numParams
	)

Definition at line 139 of file QuEST_qasm.c.

                                                                                                                                           {
     
     int len = 0;
     char line[MAX_LINE_LEN + 1]; // for trailing \0
     
     // add control labels
     for (int i=0; i < numControlQubits; i++)
         len += snprintf(line+len, MAX_LINE_LEN-len, "%s", CTRL_LABEL_PREF);
     
     // add target gate
     len += snprintf(line+len, MAX_LINE_LEN-len, "%s", qasmGateLabels[gate]);
     
     // add parameters
     if (numParams > 0) {
         len += snprintf(line+len, MAX_LINE_LEN-len, "(");
         for (int i=0; i < numParams; i++) {
             len += snprintf(line+len, MAX_LINE_LEN-len, REAL_QASM_FORMAT, params[i]);
             if (i != numParams - 1)
                 len += snprintf(line+len, MAX_LINE_LEN-len, ",");
         }
         len += snprintf(line+len, MAX_LINE_LEN-len, ")");
     }
     
     // add space
     len += snprintf(line+len, MAX_LINE_LEN-len, " ");
     
     // add control qubits
     for (int i=0; i < numControlQubits; i++)
         len += snprintf(line+len, MAX_LINE_LEN-len, "%s[%d],", QUREG_LABEL, controlQubits[i]);
     
     // add target qubit, colon and newline
     len += snprintf(line+len, MAX_LINE_LEN-len, "%s[%d];\n", QUREG_LABEL, targetQubit);
     
     // check whether we overflowed buffer
     if (len >= MAX_LINE_LEN)
         bufferOverflow();
         
     addStringToQASM(qureg, line, len);
 }

References addStringToQASM(), bufferOverflow(), CTRL_LABEL_PREF, MAX_LINE_LEN, qasmGateLabels, and QUREG_LABEL.

Referenced by qasm_recordAxisRotation(), qasm_recordCompactUnitary(), qasm_recordControlledAxisRotation(), qasm_recordControlledCompactUnitary(), qasm_recordControlledGate(), qasm_recordControlledParamGate(), qasm_recordControlledUnitary(), qasm_recordGate(), qasm_recordMultiControlledGate(), qasm_recordMultiControlledMultiQubitNot(), qasm_recordMultiControlledParamGate(), qasm_recordMultiControlledUnitary(), qasm_recordMultiStateControlledUnitary(), qasm_recordParamGate(), and qasm_recordUnitary().

◆ addMultiVarOverridesToQASM()

void addMultiVarOverridesToQASM	(	Qureg	qureg,
		int	numRegs,
		long long int *	overrideInds,
		qreal *	overridePhases,
		int	numOverrides
	)

Definition at line 600 of file QuEST_qasm.c.

                                                                                                                                 {
  
     qasm_recordComment(qureg, "  though with overrides");
  
     char line[MAX_LINE_LEN+1];
     int len = 0;
  
     // record like:
     //       |x=0, y=1, z=2> -> exp(i .45)
     //       |x=0, y=1, z=5> -> exp(i (-.5))
     int vInd=0;
     for (int v=0; v<numOverrides; v++) {
         len = 0;
         len += snprintf(line+len, MAX_LINE_LEN-len, "//     |");
         for (int r=0; r<numRegs; r++) {
             if (numRegs <= MAX_REG_SYMBS)
                 len += snprintf(line+len, MAX_LINE_LEN-len, 
                     (r<numRegs-1)? 
                         "%c=%lld, " : 
                         "%c=%lld>", 
                     getPhaseFuncSymbol(numRegs,r), 
                     overrideInds[vInd++]);
             else
                 len += snprintf(line+len, MAX_LINE_LEN-len, 
                     (r<numRegs-1)? 
                         "x%d=%lld, " : 
                         "x%d=%lld>",
                     r,
                     overrideInds[vInd++]);
         }
         len += snprintf(line+len, MAX_LINE_LEN-len, 
             (overridePhases[v] >= 0)? 
                 " -> exp(i " REAL_QASM_FORMAT ")\n" : 
                 " -> exp(i (" REAL_QASM_FORMAT "))\n", 
                 overridePhases[v]);
  
         if (len >= MAX_LINE_LEN)
             bufferOverflow();
         addStringToQASM(qureg, line, len);
     }
 }

References addStringToQASM(), bufferOverflow(), getPhaseFuncSymbol(), MAX_LINE_LEN, MAX_REG_SYMBS, and qasm_recordComment().

Referenced by qasm_recordMultiVarPhaseFunc(), and qasm_recordNamedPhaseFunc().

◆ addMultiVarRegsToQASM()

void addMultiVarRegsToQASM	(	Qureg	qureg,
		int *	qubits,
		int *	numQubitsPerReg,
		int	numRegs,
		enum bitEncoding	encoding
	)

Definition at line 571 of file QuEST_qasm.c.

                                                                                                                    {
  
     char encBuf[MAX_LINE_LEN];
     if (encoding == UNSIGNED)           sprintf(encBuf, "an unsigned");
     if (encoding == TWOS_COMPLEMENT)    sprintf(encBuf, "a two's complement");
     qasm_recordComment(qureg, "  upon substates informed by qubits (under %s binary encoding)", encBuf);
  
     char line[MAX_LINE_LEN+1];
     int len = 0;
  
     // record like:
     //     |x> = {0, 3, 2}
     //     |y> = {1, 2}
     int qInd = 0;
     for (int r=0; r<numRegs; r++) {
         len = 0;
         if (numRegs <= MAX_REG_SYMBS)
             len += snprintf(line+len, MAX_LINE_LEN-len, "//     |%c> = {", getPhaseFuncSymbol(numRegs,r));
         else
             len += snprintf(line+len, MAX_LINE_LEN-len, "//     |x%d> = {", r);
         for (int q=0; q<numQubitsPerReg[r]; q++)
             len += snprintf(line+len, MAX_LINE_LEN-len, (q < numQubitsPerReg[r]-1)? "%d, ":"%d}\n", qubits[qInd++]);
  
         if (len >= MAX_LINE_LEN)
             bufferOverflow();
         addStringToQASM(qureg, line, len);
     }
 }

References addStringToQASM(), bufferOverflow(), getPhaseFuncSymbol(), MAX_LINE_LEN, MAX_REG_SYMBS, qasm_recordComment(), TWOS_COMPLEMENT, and UNSIGNED.

Referenced by qasm_recordMultiVarPhaseFunc(), and qasm_recordNamedPhaseFunc().

◆ addShiftValuesToQASM()

void addShiftValuesToQASM	(	Qureg	qureg,
		enum phaseFunc	funcName,
		int	numRegs,
		qreal *	params
	)

Definition at line 642 of file QuEST_qasm.c.

                                                                                             {
  
     char line[MAX_LINE_LEN+1];
     int len = 0;
     int numDeltas;
     if (funcName == SCALED_INVERSE_SHIFTED_NORM)
         numDeltas = numRegs;
     else if (funcName == SCALED_INVERSE_SHIFTED_DISTANCE)
         numDeltas = numRegs / 2;
     else
         return;
  
     qasm_recordComment(qureg, "  with the additional parameters");
  
     for (int k=0; k<numDeltas; k++) {
         len = 0;
         len += snprintf(line+len, MAX_LINE_LEN-len, "//     delta%d = " REAL_QASM_FORMAT "\n", k, params[2+k]);
         if (len >= MAX_LINE_LEN)
             bufferOverflow();
         addStringToQASM(qureg, line, len);
     }
  
 }

References addStringToQASM(), bufferOverflow(), MAX_LINE_LEN, qasm_recordComment(), SCALED_INVERSE_SHIFTED_DISTANCE, and SCALED_INVERSE_SHIFTED_NORM.

Referenced by qasm_recordNamedPhaseFunc().

◆ addStringToQASM()

void addStringToQASM	(	Qureg	qureg,
		char	line[],
		int	lineLen
	)

Definition at line 93 of file QuEST_qasm.c.

                                                             {
     
     char* buf = qureg.qasmLog->buffer;
     int bufSize = qureg.qasmLog->bufferSize;
     int bufFill = qureg.qasmLog->bufferFill;
     
     // grow QASM buffer if necessary
     if (lineLen + bufFill > bufSize) {
                 
         int newBufSize = BUF_GROW_FAC * bufSize;
         if (lineLen + bufFill > newBufSize)
             bufferOverflow();
         
         char* newBuffer = malloc(newBufSize * sizeof *newBuffer);
         sprintf(newBuffer, "%s", buf);
         free(buf);
         
         qureg.qasmLog->bufferSize = newBufSize;
         qureg.qasmLog->buffer = newBuffer;
         bufSize = newBufSize;
         buf = newBuffer;
     }
         
     // add new str
     int addedChars = snprintf(buf+bufFill, bufSize-bufFill, "%s", line);
     qureg.qasmLog->bufferFill += addedChars;
 }

References BUF_GROW_FAC, bufferOverflow(), and Qureg::qasmLog.

Referenced by addGateToQASM(), addMultiVarOverridesToQASM(), addMultiVarRegsToQASM(), addShiftValuesToQASM(), qasm_recordComment(), qasm_recordInitPlus(), qasm_recordInitZero(), qasm_recordMeasurement(), qasm_recordMultiVarPhaseFunc(), qasm_recordNamedPhaseFunc(), and qasm_recordPhaseFunc().

◆ bufferOverflow()

void bufferOverflow ( void )

Definition at line 56 of file QuEST_qasm.c.

                           {
     printf("!!!\nINTERNAL ERROR: QASM line buffer filled!\n!!!");
     exit(1);
 }

Referenced by addGateToQASM(), addMultiVarOverridesToQASM(), addMultiVarRegsToQASM(), addShiftValuesToQASM(), addStringToQASM(), getPhaseFuncSymbol(), qasm_recordInitPlus(), qasm_recordInitZero(), qasm_recordMeasurement(), qasm_recordMultiVarPhaseFunc(), qasm_recordNamedPhaseFunc(), qasm_recordPhaseFunc(), and qasm_setup().

◆ getPhaseFuncSymbol()

char getPhaseFuncSymbol	(	int	numSymbs,
		int	ind
	)

Definition at line 556 of file QuEST_qasm.c.

                                                {
  
     static char xyz[7] = {'x', 'y', 'z', 't', 'r', 'v', 'u'};
     if (numSymbs <= 7)
         return xyz[ind];
  
     static char abc[MAX_REG_SYMBS] = {'a','b','c','d','e','f','g','h','j','k','l','m','n','p','q','r','s','t','u','v','w','x','y','z'}; // no i or o
     if (numSymbs <= MAX_REG_SYMBS)
         return abc[ind];
  
     // we should never reach here, since caller should handle when numSymbs > 24
     bufferOverflow();
     return 'x';
 }

References bufferOverflow(), and MAX_REG_SYMBS.

Referenced by addMultiVarOverridesToQASM(), addMultiVarRegsToQASM(), qasm_recordMultiVarPhaseFunc(), and qasm_recordNamedPhaseFunc().

◆ qasm_clearRecorded()

void qasm_clearRecorded ( Qureg qureg )

Definition at line 864 of file QuEST_qasm.c.

                                      {
     
     // maintains current buffer size
     (qureg.qasmLog->buffer)[0] = '\0';
     qureg.qasmLog->bufferFill = 0;
 }

References Qureg::qasmLog.

Referenced by clearRecordedQASM().

◆ qasm_free()

void qasm_free ( Qureg qureg )

Definition at line 887 of file QuEST_qasm.c.

                             {
     
     free(qureg.qasmLog->buffer);
     free(qureg.qasmLog);
 }

References Qureg::qasmLog.

Referenced by destroyQureg().

◆ qasm_printRecorded()

void qasm_printRecorded ( Qureg qureg )

Definition at line 871 of file QuEST_qasm.c.

                                      {
     printf("%s", qureg.qasmLog->buffer);
 }

References Qureg::qasmLog.

Referenced by printRecordedQASM().

◆ qasm_recordAxisRotation()

void qasm_recordAxisRotation	(	Qureg	qureg,
		qreal	angle,
		Vector	axis,
		int	targetQubit
	)

Definition at line 224 of file QuEST_qasm.c.

                                                                                      {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     Complex alpha, beta;
     getComplexPairFromRotation(angle, axis, &alpha, &beta);
     
     qreal rz2, ry, rz1;
     getZYZRotAnglesFromComplexPair(alpha, beta, &rz2, &ry, &rz1);
     
     qreal params[3] = {rz2, ry, rz1};
     addGateToQASM(qureg, GATE_UNITARY, NULL, 0, targetQubit, params, 3);
 }

References addGateToQASM(), GATE_UNITARY, getComplexPairFromRotation(), getZYZRotAnglesFromComplexPair(), Qureg::qasmLog, and qreal.

Referenced by rotateAroundAxis().

◆ qasm_recordComment()

void qasm_recordComment	(	Qureg	qureg,
		char *	comment,
			...
	)

Definition at line 121 of file QuEST_qasm.c.

                                                          {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     // write formatted comment to buff
     va_list argp;
     va_start(argp, comment);
     char buff[MAX_LINE_LEN - 4];
     vsnprintf(buff, MAX_LINE_LEN-5, comment, argp);
     va_end(argp);
     
     // add chars to buff, write to QASM logger
     char line[MAX_LINE_LEN + 1]; // for trailing \0
     int len = snprintf(line, MAX_LINE_LEN, "%s %s\n", COMMENT_PREF, buff);
     addStringToQASM(qureg, line, len);
 }

References addStringToQASM(), COMMENT_PREF, MAX_LINE_LEN, and Qureg::qasmLog.

Referenced by addMultiVarOverridesToQASM(), addMultiVarRegsToQASM(), addShiftValuesToQASM(), applyDiagonalOp(), applyExponentiatedPauliHamil(), applyFullQFT(), applyMatrix2(), applyMatrix4(), applyMatrixN(), applyMultiControlledMatrixN(), applyPauliHamil(), applyPauliSum(), applyProjector(), applyQFT(), applyTrotterCircuit(), controlledMultiQubitUnitary(), controlledTwoQubitUnitary(), initBlankState(), initPureState(), initStateFromAmps(), mixDephasing(), mixDepolarising(), mixKrausMap(), mixMultiQubitKrausMap(), mixPauli(), mixTwoQubitDephasing(), mixTwoQubitDepolarising(), mixTwoQubitKrausMap(), multiControlledMultiQubitUnitary(), multiControlledMultiRotatePauli(), multiControlledMultiRotateZ(), multiControlledTwoQubitUnitary(), multiQubitUnitary(), multiRotatePauli(), multiRotateZ(), qasm_recordControlledParamGate(), qasm_recordControlledUnitary(), qasm_recordInitClassical(), qasm_recordInitPlus(), qasm_recordMultiControlledMultiQubitNot(), qasm_recordMultiControlledParamGate(), qasm_recordMultiControlledUnitary(), qasm_recordMultiStateControlledUnitary(), qasm_recordMultiVarPhaseFunc(), qasm_recordNamedPhaseFunc(), qasm_recordPhaseFunc(), setAmps(), setDensityAmps(), setWeightedQureg(), and twoQubitUnitary().

◆ qasm_recordCompactUnitary()

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

Definition at line 196 of file QuEST_qasm.c.

                                                                                           {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     qreal rz2, ry, rz1;
     getZYZRotAnglesFromComplexPair(alpha, beta, &rz2, &ry, &rz1);
     
     qreal params[3] = {rz2, ry, rz1};
     addGateToQASM(qureg, GATE_UNITARY, NULL, 0, targetQubit, params, 3);
 }

References addGateToQASM(), GATE_UNITARY, getZYZRotAnglesFromComplexPair(), Qureg::qasmLog, and qreal.

Referenced by compactUnitary().

◆ qasm_recordControlledAxisRotation()

void qasm_recordControlledAxisRotation	(	Qureg	qureg,
		qreal	angle,
		Vector	axis,
		int	controlQubit,
		int	targetQubit
	)

Definition at line 301 of file QuEST_qasm.c.

                                                                                                                  {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     Complex alpha, beta;
     getComplexPairFromRotation(angle, axis, &alpha, &beta);
     
     qreal rz2, ry, rz1;
     getZYZRotAnglesFromComplexPair(alpha, beta, &rz2, &ry, &rz1);
     
     int controls[1] = {controlQubit};
     qreal params[3] = {rz2, ry, rz1};
     addGateToQASM(qureg, GATE_UNITARY, controls, 1, targetQubit, params, 3);
 }

References addGateToQASM(), GATE_UNITARY, getComplexPairFromRotation(), getZYZRotAnglesFromComplexPair(), Qureg::qasmLog, and qreal.

Referenced by controlledRotateAroundAxis().

◆ qasm_recordControlledCompactUnitary()

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

Definition at line 265 of file QuEST_qasm.c.

                                                                                                                       {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     qreal rz2, ry, rz1;
     getZYZRotAnglesFromComplexPair(alpha, beta, &rz2, &ry, &rz1);
     
     int controls[1] = {controlQubit};
     qreal params[3] = {rz2, ry, rz1};
     addGateToQASM(qureg, GATE_UNITARY, controls, 1, targetQubit, params, 3);
 }

References addGateToQASM(), GATE_UNITARY, getZYZRotAnglesFromComplexPair(), Qureg::qasmLog, and qreal.

Referenced by controlledCompactUnitary().

◆ qasm_recordControlledGate()

void qasm_recordControlledGate	(	Qureg	qureg,
		TargetGate	gate,
		int	controlQubit,
		int	targetQubit
	)

Definition at line 239 of file QuEST_qasm.c.

                                                                                                 {
  
     if (!qureg.qasmLog->isLogging)
         return;
     
     int controls[1] = {controlQubit};
     addGateToQASM(qureg, gate, controls, 1, targetQubit, 0, 0);    
 }

References addGateToQASM(), and Qureg::qasmLog.

Referenced by agnostic_applyQFT(), controlledNot(), controlledPauliY(), controlledPhaseFlip(), sqrtSwapGate(), and swapGate().

◆ qasm_recordControlledParamGate()

void qasm_recordControlledParamGate	(	Qureg	qureg,
		TargetGate	gate,
		int	controlQubit,
		int	targetQubit,
		qreal	param
	)

Definition at line 248 of file QuEST_qasm.c.

                                                                                                                   {
  
     if (!qureg.qasmLog->isLogging)
         return;
     
     int controls[1] = {controlQubit};
     qreal params[1] = {param};
     addGateToQASM(qureg, gate, controls, 1, targetQubit, params, 1);
     
     // correct the global phase of controlled phase shifts
     if (gate == GATE_PHASE_SHIFT) {
         qasm_recordComment(qureg, "Restoring the discarded global phase of the previous controlled phase gate");
         qreal phaseFix[1] = {param/2.0};
         addGateToQASM(qureg, GATE_ROTATE_Z, NULL, 0, targetQubit, phaseFix, 1);
     }
 }

References addGateToQASM(), GATE_PHASE_SHIFT, GATE_ROTATE_Z, qasm_recordComment(), Qureg::qasmLog, and qreal.

Referenced by controlledPhaseShift(), controlledRotateX(), controlledRotateY(), and controlledRotateZ().

◆ qasm_recordControlledUnitary()

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

additionally performs Rz on target to restore the global phase lost from u in QASM U(a,b,c)

Definition at line 279 of file QuEST_qasm.c.

                                                                                                     {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     Complex alpha, beta;
     qreal globalPhase;
     getComplexPairAndPhaseFromUnitary(u, &alpha, &beta, &globalPhase);
     
     qreal rz2, ry, rz1;
     getZYZRotAnglesFromComplexPair(alpha, beta, &rz2, &ry, &rz1);
     
     int controls[1] = {controlQubit};
     qreal params[3] = {rz2, ry, rz1};
     addGateToQASM(qureg, GATE_UNITARY, controls, 1, targetQubit, params, 3);
     
     // add Rz
     qasm_recordComment(qureg, "Restoring the discarded global phase of the previous controlled unitary");
     qreal phaseFix[1] = {globalPhase};
     addGateToQASM(qureg, GATE_ROTATE_Z, NULL, 0, targetQubit, phaseFix, 1);
 }

References addGateToQASM(), GATE_ROTATE_Z, GATE_UNITARY, getComplexPairAndPhaseFromUnitary(), getZYZRotAnglesFromComplexPair(), qasm_recordComment(), Qureg::qasmLog, and qreal.

Referenced by controlledUnitary().

◆ qasm_recordGate()

void qasm_recordGate	(	Qureg	qureg,
		TargetGate	gate,
		int	targetQubit
	)

Definition at line 179 of file QuEST_qasm.c.

                                                                     {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     addGateToQASM(qureg, gate, NULL, 0, targetQubit, NULL, 0);
 }

References addGateToQASM(), and Qureg::qasmLog.

Referenced by agnostic_applyQFT(), hadamard(), pauliX(), pauliY(), pauliZ(), qasm_recordInitClassical(), sGate(), and tGate().

◆ qasm_recordInitClassical()

void qasm_recordInitClassical	(	Qureg	qureg,
		long long int	stateInd
	)

Definition at line 471 of file QuEST_qasm.c.

                                                                    {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     // add an explanatory comment
     char cmt[MAX_LINE_LEN+1];
     sprintf(cmt, "Initialising state |%lld>", stateInd);
     qasm_recordComment(qureg, cmt);
     
     // start in |0>
     qasm_recordInitZero(qureg);
     
     // NOT the 1 bits in stateInd
     for (int q=0; q < qureg.numQubitsRepresented; q++) 
         if ((stateInd >> q) & 1)
             qasm_recordGate(qureg, GATE_SIGMA_X, q);
 }

References GATE_SIGMA_X, MAX_LINE_LEN, Qureg::numQubitsRepresented, qasm_recordComment(), qasm_recordGate(), qasm_recordInitZero(), and Qureg::qasmLog.

Referenced by initClassicalState().

◆ qasm_recordInitPlus()

void qasm_recordInitPlus ( Qureg qureg )

Definition at line 443 of file QuEST_qasm.c.

                                       {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     // add an explanatory comment
     char buf[MAX_LINE_LEN+1];
     sprintf(buf, "Initialising state |+>");
     qasm_recordComment(qureg, buf);
     
     // it's valid QASM to h the register (I think)
     // |+> = H |0>
     qasm_recordInitZero(qureg);
     int charsWritten = snprintf(
         buf, MAX_LINE_LEN, "%s %s;\n", 
         qasmGateLabels[GATE_HADAMARD], QUREG_LABEL);
     if (charsWritten >= MAX_LINE_LEN)
         bufferOverflow();
     addStringToQASM(qureg, buf, charsWritten);
     
     // old code (before above QASM shortcut)
     /*
     qasm_recordInitZero(qureg);
     for (int q=0; q < qureg.numQubitsRepresented; q++)
         qasm_recordGate(qureg, GATE_HADAMARD, q);
     */
 }

References addStringToQASM(), bufferOverflow(), GATE_HADAMARD, MAX_LINE_LEN, qasm_recordComment(), qasm_recordInitZero(), qasmGateLabels, Qureg::qasmLog, and QUREG_LABEL.

Referenced by initPlusState().

◆ qasm_recordInitZero()

void qasm_recordInitZero ( Qureg qureg )

Definition at line 428 of file QuEST_qasm.c.

                                       {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     char line[MAX_LINE_LEN + 1]; // for trailing \0
     int len = snprintf(line, MAX_LINE_LEN, "%s %s;\n", INIT_ZERO_CMD, QUREG_LABEL);
     
     // check whether we overflowed buffer
     if (len >= MAX_LINE_LEN)
         bufferOverflow();
     
     addStringToQASM(qureg, line, len);
 }

References addStringToQASM(), bufferOverflow(), INIT_ZERO_CMD, MAX_LINE_LEN, Qureg::qasmLog, and QUREG_LABEL.

Referenced by initZeroState(), qasm_recordInitClassical(), and qasm_recordInitPlus().

◆ qasm_recordMeasurement()

void qasm_recordMeasurement	(	Qureg	qureg,
		int	measureQubit
	)

Definition at line 411 of file QuEST_qasm.c.

                                                            {
  
     if (!qureg.qasmLog->isLogging)
         return;
     
     char line[MAX_LINE_LEN + 1]; // for trailing \0
     int len = snprintf(
         line, MAX_LINE_LEN, "%s %s[%d] -> %s[%d];\n",
         MEASURE_CMD, QUREG_LABEL, measureQubit, MESREG_LABEL, measureQubit);
         
     // check whether we overflowed buffer
     if (len >= MAX_LINE_LEN)
         bufferOverflow();
     
     addStringToQASM(qureg, line, len);
 }

References addStringToQASM(), bufferOverflow(), MAX_LINE_LEN, MEASURE_CMD, MESREG_LABEL, Qureg::qasmLog, and QUREG_LABEL.

Referenced by collapseToOutcome(), measure(), and measureWithStats().

◆ qasm_recordMultiControlledGate()

void qasm_recordMultiControlledGate	(	Qureg	qureg,
		TargetGate	gate,
		int *	controlQubits,
		int	numControlQubits,
		int	targetQubit
	)

Definition at line 317 of file QuEST_qasm.c.

                                                                                                                              {
  
     if (!qureg.qasmLog->isLogging)
         return;
     
     addGateToQASM(qureg, gate, controlQubits, numControlQubits, targetQubit, NULL, 0);
 }

References addGateToQASM(), and Qureg::qasmLog.

Referenced by multiControlledPhaseFlip().

◆ qasm_recordMultiControlledMultiQubitNot()

void qasm_recordMultiControlledMultiQubitNot	(	Qureg	qureg,
		int *	ctrls,
		int	numCtrls,
		int *	targs,
		int	numTargs
	)

Definition at line 382 of file QuEST_qasm.c.

                                                                                                               {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     qasm_recordComment(qureg, "The following %d gates resulted from a single %s() call", numTargs,
         (numCtrls > 0)? "multiControlledMultiQubitNot" : "multiQubitNot");
     
     for (int t=0; t<numTargs; t++)
         addGateToQASM(qureg, GATE_SIGMA_X, ctrls, numCtrls, targs[t], NULL, 0);
 }

References addGateToQASM(), GATE_SIGMA_X, qasm_recordComment(), and Qureg::qasmLog.

Referenced by multiControlledMultiQubitNot(), and multiQubitNot().

◆ qasm_recordMultiControlledParamGate()

void qasm_recordMultiControlledParamGate	(	Qureg	qureg,
		TargetGate	gate,
		int *	controlQubits,
		int	numControlQubits,
		int	targetQubit,
		qreal	param
	)

Definition at line 325 of file QuEST_qasm.c.

                                                                                                                                                {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     qreal params[1] = {param};
     addGateToQASM(qureg, gate, controlQubits, numControlQubits, targetQubit, params, 1);
     
     // correct the global phase of controlled phase shifts
     if (gate == GATE_PHASE_SHIFT) {
         qasm_recordComment(qureg, "Restoring the discarded global phase of the previous multicontrolled phase gate");
         qreal phaseFix[1] = {param/2.0};
         addGateToQASM(qureg, GATE_ROTATE_Z, NULL, 0, targetQubit, phaseFix, 1);
     }
 }

References addGateToQASM(), GATE_PHASE_SHIFT, GATE_ROTATE_Z, qasm_recordComment(), Qureg::qasmLog, and qreal.

Referenced by multiControlledPhaseShift().

◆ qasm_recordMultiControlledUnitary()

void qasm_recordMultiControlledUnitary	(	Qureg	qureg,
		ComplexMatrix2	u,
		int *	controlQubits,
		int	numControlQubits,
		int	targetQubit
	)

additionally performs Rz on target to restore the global phase lost from u in QASM U(a,b,c)

Definition at line 342 of file QuEST_qasm.c.

                                                                                                                                  {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     Complex alpha, beta;
     qreal globalPhase;
     getComplexPairAndPhaseFromUnitary(u, &alpha, &beta, &globalPhase);
     
     qreal rz2, ry, rz1;
     getZYZRotAnglesFromComplexPair(alpha, beta, &rz2, &ry, &rz1);
     
     qreal params[3] = {rz2, ry, rz1};
     addGateToQASM(qureg, GATE_UNITARY, controlQubits, numControlQubits, targetQubit, params, 3);
     
     // add Rz
     qasm_recordComment(qureg, "Restoring the discarded global phase of the previous multicontrolled unitary");
     qreal phaseFix[1] = {globalPhase};
     addGateToQASM(qureg, GATE_ROTATE_Z, NULL, 0, targetQubit, phaseFix, 1);
 }

References addGateToQASM(), GATE_ROTATE_Z, GATE_UNITARY, getComplexPairAndPhaseFromUnitary(), getZYZRotAnglesFromComplexPair(), qasm_recordComment(), Qureg::qasmLog, and qreal.

Referenced by multiControlledUnitary(), and qasm_recordMultiStateControlledUnitary().

◆ qasm_recordMultiStateControlledUnitary()

void qasm_recordMultiStateControlledUnitary	(	Qureg	qureg,
		ComplexMatrix2	u,
		int *	controlQubits,
		int *	controlState,
		int	numControlQubits,
		int	targetQubit
	)

Definition at line 363 of file QuEST_qasm.c.

   {
     if (!qureg.qasmLog->isLogging)
         return;
     
     qasm_recordComment(qureg, "NOTing some gates so that the subsequent unitary is controlled-on-0");
     for (int i=0; i < numControlQubits; i++)
         if (controlState[i] == 0)
             addGateToQASM(qureg, GATE_SIGMA_X, NULL, 0, controlQubits[i], NULL, 0);
     
     qasm_recordMultiControlledUnitary(qureg, u, controlQubits, numControlQubits, targetQubit);
  
     qasm_recordComment(qureg, "Undoing the NOTing of the controlled-on-0 qubits of the previous unitary");
     for (int i=0; i < numControlQubits; i++)
         if (controlState[i] == 0)
             addGateToQASM(qureg, GATE_SIGMA_X, NULL, 0, controlQubits[i], NULL, 0);
 }

References addGateToQASM(), GATE_SIGMA_X, qasm_recordComment(), qasm_recordMultiControlledUnitary(), and Qureg::qasmLog.

Referenced by multiStateControlledUnitary().

◆ qasm_recordMultiVarPhaseFunc()

void qasm_recordMultiVarPhaseFunc	(	Qureg	qureg,
		int *	qubits,
		int *	numQubitsPerReg,
		int	numRegs,
		enum bitEncoding	encoding,
		qreal *	coeffs,
		qreal *	exponents,
		int *	numTermsPerReg,
		long long int *	overrideInds,
		qreal *	overridePhases,
		int	numOverrides
	)

Definition at line 666 of file QuEST_qasm.c.

                                                                                                                                                                                                                                                       {
  
     if (!qureg.qasmLog->isLogging)
         return;
  
     qasm_recordComment(qureg, "Here, applyMultiVarPhaseFunc() multiplied a complex scalar of the form");
  
     // Here, applyMultiVarPhaseFunction() multiplied a complex scalar of the form 
     //     exp(i (
     //         .5 x^2 + .6 x + x 
     //         - y^2 - 5 y - y
     //         + z^2 + z^3 ))
  
     qasm_recordComment(qureg, "    exp(i (");
     char line[MAX_LINE_LEN+1];
     int len=0;
  
     int tFlatInd = 0;
     for (int r=0; r<numRegs; r++) {
         len = snprintf(line, MAX_LINE_LEN, "//         ");
  
         // manually force sign of first term
         len += snprintf(line+len, MAX_LINE_LEN-len, (coeffs[tFlatInd] > 0)? " + ":" - ");
  
         for (int t=0; t<numTermsPerReg[r]; t++) {
             if (numRegs <= MAX_REG_SYMBS)
                 len += snprintf(line+len, MAX_LINE_LEN-len, 
                     (exponents[tFlatInd] > 0)? 
                         REAL_QASM_FORMAT " %c^" REAL_QASM_FORMAT : 
                         REAL_QASM_FORMAT " %c^(" REAL_QASM_FORMAT ")", 
                     absReal(coeffs[tFlatInd]), 
                     getPhaseFuncSymbol(numRegs,r), 
                     exponents[tFlatInd]);
             else
                 len += snprintf(line+len, MAX_LINE_LEN-len, 
                     (exponents[tFlatInd] > 0)? 
                         REAL_QASM_FORMAT " x%d^" REAL_QASM_FORMAT : 
                         REAL_QASM_FORMAT " x%d^(" REAL_QASM_FORMAT ")", 
                     absReal(coeffs[tFlatInd]), r, exponents[tFlatInd]);
             if (t < numTermsPerReg[r]-1)
                 len += snprintf(line+len, MAX_LINE_LEN-len, (coeffs[tFlatInd+1] > 0)? " + ":" - ");                
             tFlatInd++;
         }
  
         if (r < numRegs-1)
             len += snprintf(line+len, MAX_LINE_LEN-len, "\n");
         else
             len += snprintf(line+len, MAX_LINE_LEN-len, " ))\n");
  
         if (len >= MAX_LINE_LEN)
             bufferOverflow();
         addStringToQASM(qureg, line, len);
     }
  
     addMultiVarRegsToQASM(qureg, qubits, numQubitsPerReg, numRegs, encoding);
  
     if (numOverrides > 0)
         addMultiVarOverridesToQASM(qureg, numRegs, overrideInds, overridePhases, numOverrides);
 }

References addMultiVarOverridesToQASM(), addMultiVarRegsToQASM(), addStringToQASM(), bufferOverflow(), getPhaseFuncSymbol(), MAX_LINE_LEN, MAX_REG_SYMBS, qasm_recordComment(), and Qureg::qasmLog.

Referenced by applyMultiVarPhaseFunc(), and applyMultiVarPhaseFuncOverrides().

◆ qasm_recordNamedPhaseFunc()

void qasm_recordNamedPhaseFunc	(	Qureg	qureg,
		int *	qubits,
		int *	numQubitsPerReg,
		int	numRegs,
		enum bitEncoding	encoding,
		enum phaseFunc	funcName,
		qreal *	params,
		int	numParams,
		long long int *	overrideInds,
		qreal *	overridePhases,
		int	numOverrides
	)

Definition at line 726 of file QuEST_qasm.c.

                                                                                                                                                                                                                                                     {
     // I apologise to my future self and my esteemed readers for such terrible code
  
     if (!qureg.qasmLog->isLogging)
         return;
  
     qasm_recordComment(qureg, "Here, applyNamedPhaseFunc() multiplied a complex scalar of form");
     char line[MAX_LINE_LEN+1];
  
     int len = snprintf(line, MAX_LINE_LEN, "//     exp(i ");
  
     // record norm-based function, like:  (-1.0) / sqrt(x^2 + y^2 + z^2 + ...)
     if (funcName == NORM || funcName == SCALED_NORM || 
         funcName == INVERSE_NORM || funcName == SCALED_INVERSE_NORM ||
         funcName == SCALED_INVERSE_SHIFTED_NORM)
     {
         // coefficient
         if (funcName == SCALED_NORM || funcName == SCALED_INVERSE_NORM || funcName == SCALED_INVERSE_SHIFTED_NORM)
             len += snprintf(line+len, MAX_LINE_LEN-len, 
                 (params[0]>0)? 
                     REAL_QASM_FORMAT " " : 
                     "(" REAL_QASM_FORMAT ") ", 
                 params[0]);
  
         // sqrt(
         if (funcName == NORM || funcName == SCALED_NORM)
             len += snprintf(line+len, MAX_LINE_LEN-len, "sqrt(");
         else if (funcName == INVERSE_NORM)
             len += snprintf(line+len, MAX_LINE_LEN-len, "1 / sqrt(");
         else if (funcName == SCALED_INVERSE_NORM || funcName == SCALED_INVERSE_SHIFTED_NORM)
             len += snprintf(line+len, MAX_LINE_LEN-len, "/ sqrt(");
  
         // x^2 + y^2 + ...
         if (numRegs <= MAX_REG_SYMBS)
             for (int r=0; r<numRegs; r++) {
                 if (funcName == SCALED_INVERSE_SHIFTED_NORM)
                     len += snprintf(line+len, MAX_LINE_LEN-len,
                         (params[2+r] < 0)?
                             "(%c^2+" REAL_QASM_FORMAT ")" :
                             "(%c^2-" REAL_QASM_FORMAT ")",
                         getPhaseFuncSymbol(numRegs,r), fabs(params[2+r]));
                 else
                     len += snprintf(line+len, MAX_LINE_LEN-len, "%c^2", getPhaseFuncSymbol(numRegs,r));
                 len += snprintf(line+len, MAX_LINE_LEN-len, (r < numRegs - 1)? " + ":"))\n");
             }
         else {
             if (funcName == SCALED_INVERSE_SHIFTED_NORM)
                 len += snprintf(line+len, MAX_LINE_LEN-len, "(x0-delta0)^2 + (x1-delta1)^2 + (x2-delta2)^2... ))\n");
             else
                 len += snprintf(line+len, MAX_LINE_LEN-len, "x0^2 + x1^2 + x2^2... ))\n");
         }
     }
     // record product-based, like (-1.0) 1/(x y z) ...
     else if (funcName == PRODUCT || funcName == SCALED_PRODUCT || 
         funcName == INVERSE_PRODUCT || funcName == SCALED_INVERSE_PRODUCT)
     {
         // coefficient
         if (funcName == SCALED_PRODUCT || funcName == SCALED_INVERSE_PRODUCT)
             len += snprintf(line+len, MAX_LINE_LEN-len, 
                 (params[0]>0)? 
                     REAL_QASM_FORMAT " ":
                     "(" REAL_QASM_FORMAT ") ", 
                 params[0]);
  
         // reciprocal
         if (funcName == INVERSE_PRODUCT)
             len += snprintf(line+len, MAX_LINE_LEN-len, "1 / (");
         else if (funcName == SCALED_INVERSE_PRODUCT)
             len += snprintf(line+len, MAX_LINE_LEN-len, "/ (");
  
         // x y z ...
         if (numRegs <= MAX_REG_SYMBS)
             for (int r=0; r<numRegs; r++)
                 len += snprintf(line+len, MAX_LINE_LEN-len, (r < numRegs - 1)? "%c ":"%c)", getPhaseFuncSymbol(numRegs,r));
         else
             len += snprintf(line+len, MAX_LINE_LEN-len, "x0 x1 x2 ...)");
  
         // close reciprocal brackets
         if (funcName == INVERSE_PRODUCT || funcName == SCALED_INVERSE_PRODUCT)
             len += snprintf(line+len, MAX_LINE_LEN-len, ")");
         len += snprintf(line+len, MAX_LINE_LEN-len, "\n");
     }
     // record distance-based, like (-1.0) 1/sqrt((x1-x2)^2 + (y1-y2)^2 + ...)
     else if (funcName == DISTANCE || funcName == SCALED_DISTANCE || 
         funcName == INVERSE_DISTANCE || funcName == SCALED_INVERSE_DISTANCE ||
         funcName == SCALED_INVERSE_SHIFTED_DISTANCE)
     {
         // coefficient
         if (funcName == SCALED_DISTANCE || funcName == SCALED_INVERSE_DISTANCE || funcName == SCALED_INVERSE_SHIFTED_DISTANCE)
             len += snprintf(line+len, MAX_LINE_LEN-len, 
                 (params[0]>0)? 
                     REAL_QASM_FORMAT " " :
                     "(" REAL_QASM_FORMAT ") ", 
                 params[0]);
  
         // sqrt(
         if (funcName == DISTANCE || funcName == SCALED_DISTANCE)
             len += snprintf(line+len, MAX_LINE_LEN-len, "sqrt(");
         else if (funcName == INVERSE_DISTANCE)
             len += snprintf(line+len, MAX_LINE_LEN-len, "1 / sqrt(");
         else if (funcName == SCALED_INVERSE_DISTANCE || funcName == SCALED_INVERSE_SHIFTED_DISTANCE)
             len += snprintf(line+len, MAX_LINE_LEN-len, "/ sqrt(");
  
         // (x-y)^2 + (z-t)^2 + ...
         if (numRegs <= MAX_REG_SYMBS)
             for (int r=0; r<numRegs; r+=2) {
                 if (funcName == SCALED_INVERSE_SHIFTED_DISTANCE)
                     len += snprintf(line+len, MAX_LINE_LEN-len,
                         (params[2+r/2] < 0)?
                             "(%c-%c+" REAL_QASM_FORMAT ")^2":
                             "(%c-%c-" REAL_QASM_FORMAT ")^2", 
                         getPhaseFuncSymbol(numRegs,r), getPhaseFuncSymbol(numRegs,r+1), fabs(params[2+r/2]));
                 else
                     len += snprintf(line+len, MAX_LINE_LEN-len, "(%c-%c)^2", 
                         getPhaseFuncSymbol(numRegs,r), getPhaseFuncSymbol(numRegs,r+1));
                 len += snprintf(line+len, MAX_LINE_LEN-len, (r+1 < numRegs-1)? " + ":"))\n");
             }
         else {
             if (funcName == SCALED_INVERSE_SHIFTED_DISTANCE)
                 len += snprintf(line+len, MAX_LINE_LEN-len, "(x0-x1-delta0)^2 + (x2-x3-delta1)^2 + ...))\n");
             else
                 len += snprintf(line+len, MAX_LINE_LEN-len, "(x0-x1)^2 + (x2-x3)^2 + ...))\n");
         }
     }
  
     if (len >= MAX_LINE_LEN)
         bufferOverflow();
     addStringToQASM(qureg, line, len);
  
     addMultiVarRegsToQASM(qureg, qubits, numQubitsPerReg, numRegs, encoding);
     if (numRegs > MAX_REG_SYMBS && (funcName == SCALED_INVERSE_SHIFTED_NORM || funcName == SCALED_INVERSE_SHIFTED_DISTANCE))
         addShiftValuesToQASM(qureg, funcName, numRegs, params);
  
     if (numOverrides > 0)
         addMultiVarOverridesToQASM(qureg, numRegs, overrideInds,overridePhases, numOverrides);
 }

References addMultiVarOverridesToQASM(), addMultiVarRegsToQASM(), addShiftValuesToQASM(), addStringToQASM(), bufferOverflow(), DISTANCE, getPhaseFuncSymbol(), INVERSE_DISTANCE, INVERSE_NORM, INVERSE_PRODUCT, MAX_LINE_LEN, MAX_REG_SYMBS, NORM, PRODUCT, qasm_recordComment(), Qureg::qasmLog, SCALED_DISTANCE, SCALED_INVERSE_DISTANCE, SCALED_INVERSE_NORM, SCALED_INVERSE_PRODUCT, SCALED_INVERSE_SHIFTED_DISTANCE, SCALED_INVERSE_SHIFTED_NORM, SCALED_NORM, and SCALED_PRODUCT.

Referenced by agnostic_applyQFT(), applyNamedPhaseFunc(), applyNamedPhaseFuncOverrides(), applyParamNamedPhaseFunc(), and applyParamNamedPhaseFuncOverrides().

◆ qasm_recordParamGate()

void qasm_recordParamGate	(	Qureg	qureg,
		TargetGate	gate,
		int	targetQubit,
		qreal	param
	)

Definition at line 187 of file QuEST_qasm.c.

                                                                                       {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     qreal params[1] = {param};
     addGateToQASM(qureg, gate, NULL, 0, targetQubit, params, 1);
 }

References addGateToQASM(), Qureg::qasmLog, and qreal.

Referenced by phaseShift(), rotateX(), rotateY(), and rotateZ().

◆ qasm_recordPhaseFunc()

void qasm_recordPhaseFunc	(	Qureg	qureg,
		int *	qubits,
		int	numQubits,
		enum bitEncoding	encoding,
		qreal *	coeffs,
		qreal *	exponents,
		int	numTerms,
		long long int *	overrideInds,
		qreal *	overridePhases,
		int	numOverrides
	)

Definition at line 490 of file QuEST_qasm.c.

                                                                                                                                                                                                                    {
  
     if (!qureg.qasmLog->isLogging)
         return;
  
     qasm_recordComment(qureg, "Here, applyPhaseFunc() multiplied a complex scalar of the form");
  
     // record like: 
     //     exp(i (-.5 x^2 + .5 x^(-1.5) - 1.3 x^4 ))
     char line[MAX_LINE_LEN+1];
     int len = snprintf(line, MAX_LINE_LEN, "//     exp(i (");
     for (int t=0; t<numTerms; t++) {
         len += snprintf(line+len, MAX_LINE_LEN-len, 
                 (exponents[t] > 0)? 
                     (REAL_QASM_FORMAT " x^" REAL_QASM_FORMAT) : 
                     (REAL_QASM_FORMAT " x^(" REAL_QASM_FORMAT ")"), 
                 (t>0)? 
                     absReal(coeffs[t]) : 
                     coeffs[t], 
                 exponents[t]);
         if (t < numTerms-1)
             len += snprintf(line+len, MAX_LINE_LEN-len, (coeffs[t+1] > 0)? " + ":" - ");
     }
     len += snprintf(line+len, MAX_LINE_LEN-len, "))\n");
  
     if (len >= MAX_LINE_LEN)
         bufferOverflow();
     addStringToQASM(qureg, line, len);
  
     char encBuf[MAX_LINE_LEN];
     if (encoding == UNSIGNED)           sprintf(encBuf, "an unsigned");
     if (encoding == TWOS_COMPLEMENT)    sprintf(encBuf, "a two's complement");
     qasm_recordComment(qureg, "  upon every substate |x>, informed by qubits (under %s binary encoding)", encBuf);
  
     // record like:
     //     {0, 3, 2}
     len=0;
     len = snprintf(line, MAX_LINE_LEN, "//     {");
     for (int q=0; q<numQubits; q++)
         len += snprintf(line+len, MAX_LINE_LEN-len, (q < numQubits-1)? "%d, ":"%d}\n", qubits[q]);
  
     if (len >= MAX_LINE_LEN)
         bufferOverflow();
     addStringToQASM(qureg, line, len);
  
     if (numOverrides > 0) {
         // optionally record like:
         //      |0> -> exp(i .45)
         //      |1> -> exp(i (-.5))
         qasm_recordComment(qureg, "  though with overrides");
         for (int v=0; v<numOverrides; v++)
             qasm_recordComment(qureg, (overridePhases[v] >= 0)? 
                 "    |%lld> -> exp(i " REAL_QASM_FORMAT ")" :
                 "    |%lld> -> exp(i (" REAL_QASM_FORMAT "))", 
                 overrideInds[v], overridePhases[v]);
     }
  
     // Here, applyPhaseFunction() multiplied a complex scalar of the form
     //      exp(i (.5 x^2 + .5 x^(-1.5) - 1.3 x^4 ))
     // upon every sub-state |x>, informed by qubits
     //      {0, 1, 2}
     // though with overrides
     //      |0> -> exp(i .45)
     //      |1> -> exp(i (-.5))
 }

References addStringToQASM(), bufferOverflow(), MAX_LINE_LEN, qasm_recordComment(), Qureg::qasmLog, TWOS_COMPLEMENT, and UNSIGNED.

Referenced by applyPhaseFunc(), and applyPhaseFuncOverrides().

◆ qasm_recordUnitary()

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

Definition at line 208 of file QuEST_qasm.c.

                                                                         {
     
     if (!qureg.qasmLog->isLogging)
         return;
     
     Complex alpha, beta;
     qreal discardedGlobalPhase;
     getComplexPairAndPhaseFromUnitary(u, &alpha, &beta, &discardedGlobalPhase);
     
     qreal rz2, ry, rz1;
     getZYZRotAnglesFromComplexPair(alpha, beta, &rz2, &ry, &rz1);
     
     qreal params[3] = {rz2, ry, rz1};
     addGateToQASM(qureg, GATE_UNITARY, NULL, 0, targetQubit, params, 3);
 }

References addGateToQASM(), GATE_UNITARY, getComplexPairAndPhaseFromUnitary(), getZYZRotAnglesFromComplexPair(), Qureg::qasmLog, and qreal.

Referenced by unitary().

◆ qasm_setup()

void qasm_setup ( Qureg * qureg )

Definition at line 61 of file QuEST_qasm.c.

                               {
     
     // populate and attach QASM logger
     QASMLogger *qasmLog = malloc(sizeof *qasmLog);
     qureg->qasmLog = qasmLog;
     if (qasmLog == NULL)
         bufferOverflow();
     
     qasmLog->isLogging = 0;
     qasmLog->bufferSize = BUF_INIT_SIZE;
     qasmLog->buffer = malloc(qasmLog->bufferSize * sizeof *(qasmLog->buffer));
     if (qasmLog->buffer == NULL)
         bufferOverflow();
     
     // add headers and quantum / classical register creation
     qasmLog->bufferFill = snprintf(
         qasmLog->buffer, qasmLog->bufferSize,
         "OPENQASM 2.0;\nqreg %s[%d];\ncreg %s[%d];\n", 
         QUREG_LABEL, qureg->numQubitsRepresented,
         MESREG_LABEL, qureg->numQubitsRepresented);
     if (qasmLog->bufferFill >= qasmLog->bufferSize)
         bufferOverflow();
 }

References BUF_INIT_SIZE, bufferOverflow(), MESREG_LABEL, Qureg::numQubitsRepresented, Qureg::qasmLog, and QUREG_LABEL.

Referenced by createCloneQureg(), createDensityQureg(), and createQureg().

◆ qasm_startRecording()

void qasm_startRecording ( Qureg qureg )

Definition at line 85 of file QuEST_qasm.c.

                                       {
     qureg.qasmLog->isLogging = 1;
 }

References Qureg::qasmLog.

Referenced by startRecordingQASM().

◆ qasm_stopRecording()

void qasm_stopRecording ( Qureg qureg )

Definition at line 89 of file QuEST_qasm.c.

                                      {
     qureg.qasmLog->isLogging = 0;
 }

References Qureg::qasmLog.

Referenced by stopRecordingQASM().

◆ qasm_writeRecordedToFile()

int qasm_writeRecordedToFile	(	Qureg	qureg,
		char *	filename
	)

returns success of file write

Definition at line 876 of file QuEST_qasm.c.

                                                           {
     
     FILE *file = fopen(filename, "w");
     if (file == NULL)
         return 0;
     
     fprintf(file, "%s", qureg.qasmLog->buffer);
     fclose(file);
     return 1;
 }

References Qureg::qasmLog.

Referenced by writeRecordedQASMToFile().

Variable Documentation

◆ qasmGateLabels

const char* qasmGateLabels[]

static

Initial value:

= {
    [GATE_SIGMA_X] = "x",
    [GATE_SIGMA_Y] = "y",
    [GATE_SIGMA_Z] = "z",
    [GATE_T] = "t",
    [GATE_S] = "s",
    [GATE_HADAMARD] = "h",
    [GATE_ROTATE_X] = "Rx",
    [GATE_ROTATE_Y] = "Ry",
    [GATE_ROTATE_Z] = "Rz",
    [GATE_UNITARY] = "U",     
    [GATE_PHASE_SHIFT] = "Rz",
    [GATE_SWAP] = "swap",     
    [GATE_SQRT_SWAP] = "sqrtswap" 
}

Definition at line 39 of file QuEST_qasm.c.

Referenced by addGateToQASM(), and qasm_recordInitPlus().

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ BUF_GROW_FAC

◆ BUF_INIT_SIZE

◆ COMMENT_PREF

◆ CTRL_LABEL_PREF

◆ INIT_ZERO_CMD

◆ MAX_LINE_LEN

◆ MAX_REG_SYMBS

◆ MEASURE_CMD

◆ MESREG_LABEL

◆ QUREG_LABEL

Function Documentation

◆ addGateToQASM()

◆ addMultiVarOverridesToQASM()

◆ addMultiVarRegsToQASM()

◆ addShiftValuesToQASM()

◆ addStringToQASM()

◆ bufferOverflow()

◆ getPhaseFuncSymbol()

◆ qasm_clearRecorded()

◆ qasm_free()

◆ qasm_printRecorded()

◆ qasm_recordAxisRotation()

◆ qasm_recordComment()

◆ qasm_recordCompactUnitary()

◆ qasm_recordControlledAxisRotation()

◆ qasm_recordControlledCompactUnitary()

◆ qasm_recordControlledGate()

◆ qasm_recordControlledParamGate()

◆ qasm_recordControlledUnitary()

◆ qasm_recordGate()

◆ qasm_recordInitClassical()

◆ qasm_recordInitPlus()

◆ qasm_recordInitZero()

◆ qasm_recordMeasurement()

◆ qasm_recordMultiControlledGate()

◆ qasm_recordMultiControlledMultiQubitNot()

◆ qasm_recordMultiControlledParamGate()

◆ qasm_recordMultiControlledUnitary()

◆ qasm_recordMultiStateControlledUnitary()

◆ qasm_recordMultiVarPhaseFunc()

◆ qasm_recordNamedPhaseFunc()

◆ qasm_recordParamGate()

◆ qasm_recordPhaseFunc()

◆ qasm_recordUnitary()

◆ qasm_setup()

◆ qasm_startRecording()

◆ qasm_stopRecording()

◆ qasm_writeRecordedToFile()

Variable Documentation

◆ qasmGateLabels