qinterface.hpp

Go to the documentation of this file.

//
// (C) Daniel Strano and the Qrack contributors 2017, 2018. All rights reserved.
//
// This is a multithreaded, universal quantum register simulation, allowing
// (nonphysical) register cloning and direct measurement of probability and
// phase, to leverage what advantages classical emulation of qubits can have.
//
// Licensed under the GNU General Public License V3.
// See LICENSE.md in the project root or https://www.gnu.org/licenses/gpl-3.0.en.html
// for details.

#pragma once

#include <ctime>
#include <map>
#include <math.h>
#include <memory>
#include <random>
#include <vector>
#define bitLenInt uint8_t
#define bitCapInt uint64_t
#define bitsInByte 8

#include "config.h"

#if ENABLE_COMPLEX8
#include <complex>
#define complex std::complex<float>
#define real1 float
#define min_norm 1e-9
#define polar(A, B) std::polar(A, B)
#else
#include "common/complex16simd.hpp"
#define complex Complex16Simd
#define real1 double
#define min_norm 1e-15
#endif

// The state vector must be an aligned piece of RAM, to be used by OpenCL.
// We align to an ALIGN_SIZE byte boundary.
#define ALIGN_SIZE 64

namespace Qrack {

class QInterface;
typedef std::shared_ptr<QInterface> QInterfacePtr;

enum QInterfaceEngine {

    QINTERFACE_CPU = 0,
    QINTERFACE_OPENCL,

    QINTERFACE_OPENCL_MULTI,

    QINTERFACE_QUNIT,

    QINTERFACE_FIRST = QINTERFACE_CPU,
#if ENABLE_OPENCL
    QINTERFACE_OPTIMAL = QINTERFACE_OPENCL,
#else
    QINTERFACE_OPTIMAL = QINTERFACE_CPU,
#endif

    QINTERFACE_MAX
};

class QInterface {
protected:
    bitLenInt qubitCount;
    bitCapInt maxQPower;
    real1 runningNorm;
    bool doNormalize;

    uint32_t randomSeed;
    std::shared_ptr<std::default_random_engine> rand_generator;
    std::uniform_real_distribution<real1> rand_distribution;

    virtual void SetQubitCount(bitLenInt qb)
    {
        qubitCount = qb;
        maxQPower = 1 << qubitCount;
    }

    virtual real1 Rand() { return rand_distribution(*rand_generator); }
    virtual void SetRandomSeed(uint32_t seed) { rand_generator->seed(seed); }

    virtual void Apply2x2(bitCapInt offset1, bitCapInt offset2, const complex* mtrx, const bitLenInt bitCount,
        const bitCapInt* qPowersSorted, bool doCalcNorm) = 0;
    virtual void ApplyControlled2x2(bitLenInt control, bitLenInt target, const complex* mtrx, bool doCalcNorm);
    virtual void ApplyAntiControlled2x2(bitLenInt control, bitLenInt target, const complex* mtrx, bool doCalcNorm);
    virtual void ApplyDoublyControlled2x2(
        bitLenInt control1, bitLenInt control2, bitLenInt target, const complex* mtrx, bool doCalcNorm);
    virtual void ApplyDoublyAntiControlled2x2(
        bitLenInt control1, bitLenInt control2, bitLenInt target, const complex* mtrx, bool doCalcNorm);
    virtual void ApplyM(bitCapInt qPower, bool result, complex nrm) = 0;
    virtual void NormalizeState(real1 nrm = -999.0) = 0;

public:
    QInterface(bitLenInt n, std::shared_ptr<std::default_random_engine> rgp = nullptr, bool doNorm = true)
        : doNormalize(doNorm)
        , rand_distribution(0.0, 1.0)
    {
        SetQubitCount(n);

        if (rgp == NULL) {
            rand_generator = std::make_shared<std::default_random_engine>();
            randomSeed = std::time(0);
            SetRandomSeed(randomSeed);
        } else {
            rand_generator = rgp;
        }
    }

    virtual ~QInterface(){};

    int GetQubitCount() { return qubitCount; }

    int GetMaxQPower() { return maxQPower; }

    virtual void SetQuantumState(complex* inputState) = 0;

    virtual void SetPermutation(bitCapInt perm) = 0;

    virtual bitLenInt Cohere(QInterfacePtr toCopy) = 0;
    virtual std::map<QInterfacePtr, bitLenInt> Cohere(std::vector<QInterfacePtr> toCopy);

    virtual void Decohere(bitLenInt start, bitLenInt length, QInterfacePtr dest) = 0;

    virtual void Dispose(bitLenInt start, bitLenInt length) = 0;

    virtual void ApplySingleBit(const complex* mtrx, bool doCalcNorm, bitLenInt qubitIndex);

    virtual void CCNOT(bitLenInt control1, bitLenInt control2, bitLenInt target);

    virtual void AntiCCNOT(bitLenInt control1, bitLenInt control2, bitLenInt target);

    virtual void CNOT(bitLenInt control, bitLenInt target);

    virtual void AntiCNOT(bitLenInt control, bitLenInt target);

    virtual void H(bitLenInt qubitIndex);

    virtual bool M(bitLenInt qubitIndex);

    virtual void X(bitLenInt qubitIndex);

    virtual void Y(bitLenInt qubitIndex);

    virtual void Z(bitLenInt qubitIndex);

    virtual void CY(bitLenInt control, bitLenInt target);

    virtual void CZ(bitLenInt control, bitLenInt target);

    virtual void AND(bitLenInt inputBit1, bitLenInt inputBit2, bitLenInt outputBit);

    virtual void OR(bitLenInt inputBit1, bitLenInt inputBit2, bitLenInt outputBit);

    virtual void XOR(bitLenInt inputBit1, bitLenInt inputBit2, bitLenInt outputBit);

    virtual void CLAND(bitLenInt inputQBit, bool inputClassicalBit, bitLenInt outputBit);

    virtual void CLOR(bitLenInt inputQBit, bool inputClassicalBit, bitLenInt outputBit);

    virtual void CLXOR(bitLenInt inputQBit, bool inputClassicalBit, bitLenInt outputBit);

    virtual void RT(real1 radians, bitLenInt qubitIndex);

    virtual void RTDyad(int numerator, int denomPower, bitLenInt qubitIndex);

    virtual void RX(real1 radians, bitLenInt qubitIndex);

    virtual void RXDyad(int numerator, int denomPower, bitLenInt qubitIndex);

    virtual void Exp(real1 radians, bitLenInt qubitIndex);

    virtual void ExpDyad(int numerator, int denomPower, bitLenInt qubitIndex);

    virtual void ExpX(real1 radians, bitLenInt qubitIndex);

    virtual void ExpXDyad(int numerator, int denomPower, bitLenInt qubitIndex);

    virtual void ExpY(real1 radians, bitLenInt qubitIndex);

    virtual void ExpYDyad(int numerator, int denomPower, bitLenInt qubitIndex);

    virtual void ExpZ(real1 radians, bitLenInt qubitIndex);

    virtual void ExpZDyad(int numerator, int denomPower, bitLenInt qubitIndex);

    virtual void CRX(real1 radians, bitLenInt control, bitLenInt target);

    virtual void CRXDyad(int numerator, int denomPower, bitLenInt control, bitLenInt target);

    virtual void RY(real1 radians, bitLenInt qubitIndex);

    virtual void RYDyad(int numerator, int denomPower, bitLenInt qubitIndex);

    virtual void CRY(real1 radians, bitLenInt control, bitLenInt target);

    virtual void CRYDyad(int numerator, int denomPower, bitLenInt control, bitLenInt target);

    virtual void RZ(real1 radians, bitLenInt qubitIndex);

    virtual void RZDyad(int numerator, int denomPower, bitLenInt qubitIndex);

    virtual void CRZ(real1 radians, bitLenInt control, bitLenInt target);

    virtual void CRZDyad(int numerator, int denomPower, bitLenInt control, bitLenInt target);

    virtual void CRT(real1 radians, bitLenInt control, bitLenInt target);

    virtual void CRTDyad(int numerator, int denomPower, bitLenInt control, bitLenInt target);

    virtual void H(bitLenInt start, bitLenInt length);

    virtual void X(bitLenInt start, bitLenInt length);

    virtual void Y(bitLenInt start, bitLenInt length);

    virtual void Z(bitLenInt start, bitLenInt length);

    virtual void CNOT(bitLenInt inputBits, bitLenInt targetBits, bitLenInt length);

    virtual void AntiCNOT(bitLenInt inputBits, bitLenInt targetBits, bitLenInt length);

    virtual void CCNOT(bitLenInt control1, bitLenInt control2, bitLenInt target, bitLenInt length);

    virtual void AntiCCNOT(bitLenInt control1, bitLenInt control2, bitLenInt target, bitLenInt length);

    virtual void AND(bitLenInt inputStart1, bitLenInt inputStart2, bitLenInt outputStart, bitLenInt length);

    virtual void CLAND(bitLenInt qInputStart, bitCapInt classicalInput, bitLenInt outputStart, bitLenInt length);

    virtual void OR(bitLenInt inputStart1, bitLenInt inputStart2, bitLenInt outputStart, bitLenInt length);

    virtual void CLOR(bitLenInt qInputStart, bitCapInt classicalInput, bitLenInt outputStart, bitLenInt length);

    virtual void XOR(bitLenInt inputStart1, bitLenInt inputStart2, bitLenInt outputStart, bitLenInt length);

    virtual void CLXOR(bitLenInt qInputStart, bitCapInt classicalInput, bitLenInt outputStart, bitLenInt length);

    virtual void RT(real1 radians, bitLenInt start, bitLenInt length);

    virtual void RTDyad(int numerator, int denomPower, bitLenInt start, bitLenInt length);

    virtual void RX(real1 radians, bitLenInt start, bitLenInt length);

    virtual void RXDyad(int numerator, int denomPower, bitLenInt start, bitLenInt length);

    virtual void CRX(real1 radians, bitLenInt control, bitLenInt target, bitLenInt length);

    virtual void CRXDyad(int numerator, int denomPower, bitLenInt control, bitLenInt target, bitLenInt length);

    virtual void RY(real1 radians, bitLenInt start, bitLenInt length);

    virtual void RYDyad(int numerator, int denomPower, bitLenInt start, bitLenInt length);

    virtual void CRY(real1 radians, bitLenInt control, bitLenInt target, bitLenInt length);

    virtual void CRYDyad(int numerator, int denomPower, bitLenInt control, bitLenInt target, bitLenInt length);

    virtual void RZ(real1 radians, bitLenInt start, bitLenInt length);

    virtual void RZDyad(int numerator, int denomPower, bitLenInt start, bitLenInt length);

    virtual void CRZ(real1 radians, bitLenInt control, bitLenInt target, bitLenInt length);

    virtual void CRZDyad(int numerator, int denomPower, bitLenInt control, bitLenInt target, bitLenInt length);

    virtual void CRT(real1 radians, bitLenInt control, bitLenInt target, bitLenInt length);

    virtual void CRTDyad(int numerator, int denomPower, bitLenInt control, bitLenInt target, bitLenInt length);

    virtual void Exp(real1 radians, bitLenInt start, bitLenInt length);

    virtual void ExpDyad(int numerator, int denomPower, bitLenInt start, bitLenInt length);

    virtual void ExpX(real1 radians, bitLenInt start, bitLenInt length);

    virtual void ExpXDyad(int numerator, int denomPower, bitLenInt start, bitLenInt length);

    virtual void ExpY(real1 radians, bitLenInt start, bitLenInt length);

    virtual void ExpYDyad(int numerator, int denomPower, bitLenInt start, bitLenInt length);

    virtual void ExpZ(real1 radians, bitLenInt start, bitLenInt length);

    virtual void ExpZDyad(int numerator, int denomPower, bitLenInt start, bitLenInt length);

    virtual void CY(bitLenInt control, bitLenInt target, bitLenInt length);

    virtual void CZ(bitLenInt control, bitLenInt target, bitLenInt length);

    virtual void ASL(bitLenInt shift, bitLenInt start, bitLenInt length);

    virtual void ASR(bitLenInt shift, bitLenInt start, bitLenInt length);

    virtual void LSL(bitLenInt shift, bitLenInt start, bitLenInt length);

    virtual void LSR(bitLenInt shift, bitLenInt start, bitLenInt length);

    virtual void ROL(bitLenInt shift, bitLenInt start, bitLenInt length);

    virtual void ROR(bitLenInt shift, bitLenInt start, bitLenInt length);

    virtual void INC(bitCapInt toAdd, bitLenInt start, bitLenInt length) = 0;

    virtual void INCC(bitCapInt toAdd, bitLenInt start, bitLenInt length, bitLenInt carryIndex) = 0;

    virtual void INCS(bitCapInt toAdd, bitLenInt start, bitLenInt length, bitLenInt overflowIndex) = 0;

    virtual void INCSC(
        bitCapInt toAdd, bitLenInt start, bitLenInt length, bitLenInt overflowIndex, bitLenInt carryIndex) = 0;

    virtual void INCSC(bitCapInt toAdd, bitLenInt start, bitLenInt length, bitLenInt carryIndex) = 0;

    virtual void INCBCD(bitCapInt toAdd, bitLenInt start, bitLenInt length) = 0;

    virtual void INCBCDC(bitCapInt toAdd, bitLenInt start, bitLenInt length, bitLenInt carryIndex) = 0;

    virtual void DEC(bitCapInt toSub, bitLenInt start, bitLenInt length) = 0;

    virtual void DECC(bitCapInt toSub, bitLenInt start, bitLenInt length, bitLenInt carryIndex) = 0;

    virtual void DECS(bitCapInt toAdd, bitLenInt start, bitLenInt length, bitLenInt overflowIndex) = 0;

    virtual void DECSC(
        bitCapInt toAdd, bitLenInt start, bitLenInt length, bitLenInt overflowIndex, bitLenInt carryIndex) = 0;

    virtual void DECSC(bitCapInt toAdd, bitLenInt start, bitLenInt length, bitLenInt carryIndex) = 0;

    virtual void DECBCD(bitCapInt toAdd, bitLenInt start, bitLenInt length) = 0;

    virtual void DECBCDC(bitCapInt toSub, bitLenInt start, bitLenInt length, bitLenInt carryIndex) = 0;

    virtual void MUL(
        bitCapInt toMul, bitLenInt inOutStart, bitLenInt carryStart, bitLenInt length, bool clearCary = false) = 0;

    virtual void DIV(bitCapInt toDiv, bitLenInt inOutStart, bitLenInt carryStart, bitLenInt length) = 0;

    virtual void CMUL(bitCapInt toMul, bitLenInt inOutStart, bitLenInt carryStart, bitLenInt controlBit,
        bitLenInt length, bool clearCarry = false) = 0;

    virtual void CDIV(
        bitCapInt toDiv, bitLenInt inOutStart, bitLenInt carryStart, bitLenInt controlBit, bitLenInt length) = 0;

    virtual void QFT(bitLenInt start, bitLenInt length);

    virtual void ZeroPhaseFlip(bitLenInt start, bitLenInt length) = 0;

    virtual void CPhaseFlipIfLess(bitCapInt greaterPerm, bitLenInt start, bitLenInt length, bitLenInt flagIndex) = 0;

    virtual void PhaseFlip() = 0;

    virtual void SetReg(bitLenInt start, bitLenInt length, bitCapInt value);

    virtual bitCapInt MReg(bitLenInt start, bitLenInt length);

    virtual bitCapInt IndexedLDA(bitLenInt indexStart, bitLenInt indexLength, bitLenInt valueStart,
        bitLenInt valueLength, unsigned char* values) = 0;

    virtual bitCapInt IndexedADC(bitLenInt indexStart, bitLenInt indexLength, bitLenInt valueStart,
        bitLenInt valueLength, bitLenInt carryIndex, unsigned char* values) = 0;

    virtual bitCapInt IndexedSBC(bitLenInt indexStart, bitLenInt indexLength, bitLenInt valueStart,
        bitLenInt valueLength, bitLenInt carryIndex, unsigned char* values) = 0;

    virtual void Swap(bitLenInt qubitIndex1, bitLenInt qubitIndex2);

    virtual void Swap(bitLenInt start1, bitLenInt start2, bitLenInt length);

    virtual void Reverse(bitLenInt first, bitLenInt last)
    {
        while ((first < last) && (first < (last - 1))) {
            last--;
            Swap(first, last);
            first++;
        }
    }

    virtual void CopyState(QInterfacePtr orig) = 0;

    virtual real1 Prob(bitLenInt qubitIndex) = 0;

    virtual real1 ProbAll(bitCapInt fullRegister) = 0;

    virtual void SetBit(bitLenInt qubitIndex1, bool value);

    virtual bool ForceM(bitLenInt qubitIndex, bool result, bool doForce = true, real1 nrmlzr = 1.0);

};
} // namespace Qrack