qinterface.hpp

Go to the documentation of this file.

//
// (C) Daniel Strano 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 <map>
#include <math.h>
#include <memory>
#include <vector>

#define bitLenInt uint8_t
#define bitCapInt uint64_t
#define bitsInByte 8

#include "common/complex16simd.hpp"

#if ENABLE_AVX
#include "common/complex16x2simd.hpp"
#endif

#define complex Complex16Simd

namespace Qrack {

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

enum QInterfaceEngine {

    QINTERFACE_CPU = 0,
    QINTERFACE_OPENCL,

    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;

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

public:
    QInterface(bitLenInt n) { SetQubitCount(n); }

    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) = 0;

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

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

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

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

    virtual void CNOT(bitLenInt control, bitLenInt target) = 0;

    virtual void AntiCNOT(bitLenInt control, bitLenInt target) = 0;

    virtual void H(bitLenInt qubitIndex) = 0;

    virtual bool M(bitLenInt qubitIndex) = 0;

    virtual void X(bitLenInt qubitIndex) = 0;

    virtual void Y(bitLenInt qubitIndex) = 0;

    virtual void Z(bitLenInt qubitIndex) = 0;

    virtual void CY(bitLenInt control, bitLenInt target) = 0;

    virtual void CZ(bitLenInt control, bitLenInt target) = 0;

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

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

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

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

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

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

    virtual void RT(double radians, bitLenInt qubitIndex) = 0;

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

    virtual void RX(double radians, bitLenInt qubitIndex) = 0;

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

    virtual void CRX(double radians, bitLenInt control, bitLenInt target) = 0;

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

    virtual void RY(double radians, bitLenInt qubitIndex) = 0;

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

    virtual void CRY(double radians, bitLenInt control, bitLenInt target) = 0;

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

    virtual void RZ(double radians, bitLenInt qubitIndex) = 0;

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

    virtual void CRZ(double radians, bitLenInt control, bitLenInt target) = 0;

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

    virtual void CRT(double radians, bitLenInt control, bitLenInt target) = 0;

    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(double radians, bitLenInt start, bitLenInt length);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    virtual void CRTDyad(int numerator, int denomPower, bitLenInt control, bitLenInt target, 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) = 0;

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

    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 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) = 0;

    virtual bitCapInt MReg(bitLenInt start, bitLenInt length) = 0;

    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) = 0;

    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 double Prob(bitLenInt qubitIndex) = 0;

    virtual double ProbAll(bitCapInt fullRegister) = 0;

    virtual void SetBit(bitLenInt qubitIndex1, bool value);

};
} // namespace Qrack