utilities.hpp

 
#ifndef QUEST_TEST_UTILS_H
#define QUEST_TEST_UTILS_H
 
#include "QuEST.h"
#include "QuEST_complex.h"
#include "catch.hpp"
#include <vector>
 
extern QuESTEnv QUEST_ENV;
 
#define NUM_QUBITS 5
 
#ifndef M_PI
#define M_PI 3.141592653589793238
#endif
 
#define VLA(type, name, len) \
    std::vector<type> name##_vla_hack_vec(len); \
    type* name = name##_vla_hack_vec.data();
 
typedef std::vector<std::vector<qcomp>> QMatrix;
 
typedef std::vector<qcomp> QVector;
 
void assertQuregAndRefInDebugState(Qureg qureg, QVector ref);
 
void assertQuregAndRefInDebugState(Qureg qureg, QMatrix ref);
 
/* (Excluded from Doxygen doc)
 *
 * Define QVector and QMatrix operator overloads.
 * Note that QMatrix overloads don't simply use QVector 
 * overloads, since the complex vector dot product involves 
 * conjugation, which doesn't occur in complex matrix multiplication.
 * Note too we also avoid defining operators in terms of other operators
 * (e.g. minus is plus(negative times)) since compiler optimisations 
 * may change the order of operations and confuse the overloads invoked.
 * Definition of division using multiplication can furthermore 
 * heighten numerical errors.
 *
 * @ingroup testutilities
 * @author Tyson Jones
 */
QVector operator + (const QVector& v1, const QVector& v2);
QVector operator - (const QVector& v1, const QVector& v2);
QVector operator * (const qcomp& a, const QVector& v);
QVector operator * (const QVector& v, const qcomp& a);
QVector operator / (const QVector& v, const qcomp& a);
qcomp operator * (const QVector &v1, const QVector& v2);
void operator += (QVector& v1, const QVector& v2);
void operator -= (QVector& v1, const QVector& v2);
void operator *= (QVector& v1, const qcomp& a);
void operator /= (QVector& v1, const qcomp& a);
QMatrix operator + (const QMatrix& m1, const QMatrix& m2);
QMatrix operator - (const QMatrix& m1, const QMatrix& m2);
QMatrix operator * (const qcomp& a, const QMatrix& m);
QMatrix operator * (const QMatrix& m, const qcomp& a);
QMatrix operator / (const QMatrix& m, const qcomp& a);
QMatrix operator * (const QMatrix& m1, const QMatrix& m2);
void operator += (QMatrix& m1, const QMatrix& m2);
void operator -= (QMatrix& m1, const QMatrix& m2);
void operator *= (QMatrix& m1, const qreal& a);
void operator /= (QMatrix& m1, const qreal& a);
void operator *= (QMatrix& m1, const QMatrix& m2);
QVector operator * (const QMatrix& m, const QVector& v);
 
QVector toQVector(Qureg qureg);
 
QVector toQVector(DiagonalOp op);
 
QMatrix toQMatrix(Qureg qureg);
 
QMatrix toQMatrix(Complex alpha, Complex beta);
 
QMatrix toQMatrix(ComplexMatrix2 src);
 
QMatrix toQMatrix(ComplexMatrix4 src);
 
QMatrix toQMatrix(ComplexMatrixN src);
 
QMatrix toQMatrix(qreal* coeffs, pauliOpType* paulis, int numQubits, int numTerms);
 
QMatrix toQMatrix(PauliHamil hamil);
 
QMatrix toQMatrix(DiagonalOp op);
 
QMatrix toQMatrix(SubDiagonalOp op);
 
QMatrix toDiagonalQMatrix(QVector vec);
 
ComplexMatrix2 toComplexMatrix2(QMatrix qm);
 
ComplexMatrix4 toComplexMatrix4(QMatrix qm);
 
void toComplexMatrixN(QMatrix qm, ComplexMatrixN cm);
 
void toQureg(Qureg qureg, QVector vec);
 
void toQureg(Qureg qureg, QMatrix mat);
 
QVector getKroneckerProduct(QVector b, QVector a);
 
QMatrix getZeroMatrix(size_t dim);
 
QMatrix getIdentityMatrix(size_t dim);
 
QMatrix getExponentialOfDiagonalMatrix(QMatrix a);
 
QMatrix getExponentialOfPauliMatrix(qreal angle, QMatrix a);
 
QMatrix getKroneckerProduct(QMatrix a, QMatrix b);
 
QMatrix getSwapMatrix(int qb1, int qb2, int numQb);
 
QMatrix getFullOperatorMatrix(int* ctrls, int numCtrls, int *targs, int numTargs, QMatrix op, int numQubits);
 
QMatrix getKetBra(QVector ket, QVector bra);
 
QMatrix getConjugateTranspose(QMatrix a);
 
int getRandomInt(int min, int max);
 
qreal getRandomReal(qreal min, qreal max);
 
qcomp getRandomComplex();
 
QVector getRandomQVector(int dim);
 
QMatrix getRandomQMatrix(int dim);
 
QMatrix getRandomUnitary(int numQb);
 
QVector getRandomStateVector(int numQb);
 
QMatrix getRandomDensityMatrix(int numQb);
 
QMatrix getRandomPureDensityMatrix(int numQb);
 
QMatrix getPureDensityMatrix(QVector state);
 
QVector getMatrixDiagonal(QMatrix matr);
 
std::vector<QMatrix> getRandomKrausMap(int numQb, int numOps);
 
std::vector<qreal> getRandomProbabilities(int numProbs);
 
std::vector<QVector> getRandomOrthonormalVectors(int numQb, int numStates);
 
QMatrix getMixedDensityMatrix(std::vector<qreal> probs, std::vector<QVector> states);
 
QVector getNormalised(QVector vec);
 
QVector getDFT(QVector in);
 
QVector getDFT(QVector in, int* targs, int numTargs);
 
long long int getValueOfTargets(long long int ind, int* targs, int numTargs);
 
void setSubMatrix(QMatrix &dest, QMatrix sub, size_t r, size_t c);
 
void applyReferenceOp(QMatrix &state, int* ctrls, int numCtrls, int *targs, int numTargs, QMatrix op);
 
void applyReferenceOp(QMatrix &state, int* ctrls, int numCtrls, int targ1, int targ2, QMatrix op);
 
void applyReferenceOp(QMatrix &state, int* ctrls, int numCtrls, int target, QMatrix op);
 
void applyReferenceOp(QMatrix &state, int *targs, int numTargs, QMatrix op);
 
void applyReferenceOp(QMatrix &state, int ctrl, int targ, QMatrix op);
 
void applyReferenceOp(QMatrix &state, int ctrl, int* targs, int numTargs, QMatrix op);
 
void applyReferenceOp(QMatrix &state, int ctrl, int targ1, int targ2, QMatrix op);
 
void applyReferenceOp(QMatrix &state, int targ, QMatrix op);
 
void applyReferenceOp(QVector &state, int* ctrls, int numCtrls, int *targs, int numTargs, QMatrix op);
 
void applyReferenceOp(QVector &state, int* ctrls, int numCtrls, int targ1, int targ2, QMatrix op);
 
void applyReferenceOp(QVector &state, int* ctrls, int numCtrls, int target, QMatrix op);
 
void applyReferenceOp(QVector &state, int *targs, int numTargs, QMatrix op);
 
void applyReferenceOp(QVector &state, int ctrl, int targ, QMatrix op);
 
void applyReferenceOp(QVector &state, int ctrl, int* targs, int numTargs, QMatrix op);
 
void applyReferenceOp(QVector &state, int ctrl, int targ1, int targ2, QMatrix op);
 
void applyReferenceOp(QVector &state, int targ, QMatrix op);
 
void applyReferenceMatrix(QVector &state, int* ctrls, int numCtrls, int *targs, int numTargs, QMatrix op);
 
void applyReferenceMatrix(QVector &state, int *targs, int numTargs, QMatrix op);
 
void applyReferenceMatrix(QMatrix &state, int* ctrls, int numCtrls, int *targs, int numTargs, QMatrix op);
 
void applyReferenceMatrix(QMatrix &state, int *targs, int numTargs, QMatrix op); 
 
bool areEqual(Qureg qureg1, Qureg qureg2);
 
bool areEqual(Qureg qureg, QVector vec);
 
bool areEqual(Qureg qureg, QMatrix matr);
 
bool areEqual(Qureg qureg1, Qureg qureg2, qreal precision);
 
bool areEqual(Qureg qureg, QVector vec, qreal precision);
 
bool areEqual(Qureg qureg, QMatrix matr, qreal precision);
 
bool areEqual(QVector a, QVector b);
 
bool areEqual(QMatrix a, QMatrix b);
 
bool areEqual(QVector vec, qreal* reals, qreal* imags);
 
bool areEqual(QVector vec, qreal* reals);
 
qcomp expI(qreal phase);
 
unsigned int calcLog2(long unsigned int res);
 
void setRandomPauliSum(qreal* coeffs, pauliOpType* codes, int numQubits, int numTerms);
 
void setRandomPauliSum(PauliHamil hamil);
 
void setRandomDiagPauliHamil(PauliHamil hamil);
 
void setRandomTargets(int* targs, int numTargs, int numQb);
 
long long int getTwosComplement(long long int decimal, int numBits);
 
long long int getUnsigned(long long int twosComp, int numBits);
 
void setDiagMatrixOverrides(QMatrix &matr, int* numQubitsPerReg, int numRegs, enum bitEncoding encoding, long long int* overrideInds, qreal* overridePhases, int numOverrides);
 
void setUniqueFilename(char* outFn, char* prefix);
 
void writeToFileSynch(char* fn, const string& contents);
 
void deleteFilesWithPrefixSynch(char* prefix);
 
// makes below signatures more concise
template<class T> using CatchGen = Catch::Generators::GeneratorWrapper<T>;
 
CatchGen<int*> sublists(int* list, int len, int sublen);
 
CatchGen<int*> sublists(CatchGen<int>&& gen, int numSamps, const int* exclude, int numExclude);
 
CatchGen<int*> sublists(CatchGen<int>&& gen, int numSamps, int excluded);
 
CatchGen<int*> sublists(CatchGen<int>&& gen, int sublen);
 
CatchGen<int*> bitsets(int numBits);
 
CatchGen<int*> sequences(int base, int numDigits);
 
CatchGen<pauliOpType*> pauliseqs(int numPaulis);
 
#endif // QUEST_TEST_UTILS_H