QuestLibSim.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _QUEST_LIB_SIM_H_
#define _QUEST_LIB_SIM_H_
 
#include "../../Utils/Library.h"
#include <complex>
#include <vector>
 
namespace Simulators
{
 
// use it as a singleton
class QuestLibSim : public Utils::Library
{
  public:
    QuestLibSim(const QuestLibSim &) = delete;
    QuestLibSim &operator=(const QuestLibSim &) = delete;
 
    QuestLibSim(QuestLibSim &&) = default;
    QuestLibSim &operator=(QuestLibSim &&) = default;
 
    QuestLibSim() noexcept
    {
    }
 
    virtual ~QuestLibSim()
    {
        if (initialized && fFinalize)
        {
            fFinalize();
            initialized = false;
        }
    }
 
    bool Init(const char *libName) noexcept override
    {
        if (Utils::Library::Init(libName))
        {
            fInitialize = (void (*)())GetFunction("Initialize");
            CheckFunction((void *)fInitialize, __LINE__);
            fFinalize = (void (*)())GetFunction("Finalize");
            CheckFunction((void *)fFinalize, __LINE__);
 
            fCreateSimulator = (unsigned long int (*)(int))GetFunction("CreateSimulator");
            CheckFunction((void *)fCreateSimulator, __LINE__);
            fDestroySimulator = (void (*)(unsigned long int))GetFunction("DestroySimulator");
            CheckFunction((void *)fDestroySimulator, __LINE__);
            fCloneSimulator = (unsigned long int (*)(void *))GetFunction("CloneSimulator");
            CheckFunction((void *)fCloneSimulator, __LINE__);
            fGetSimulator = (void *(*)(unsigned long int))GetFunction("GetSimulator");
            CheckFunction((void *)fGetSimulator, __LINE__);
 
            fGetNumQubits = (int (*)(void *))GetFunction("GetNumQubits");
            CheckFunction((void *)fGetNumQubits, __LINE__);
            fGetQubitProbability0 = (double (*)(void *, int))GetFunction("GetQubitProbability0");
            CheckFunction((void *)fGetQubitProbability0, __LINE__);
            fGetQubitProbability1 = (double (*)(void *, int))GetFunction("GetQubitProbability1");
            CheckFunction((void *)fGetQubitProbability1, __LINE__);
            fGetOutcomeProbability = (double (*)(void *, long long int))GetFunction("GetOutcomeProbability");
            CheckFunction((void *)fGetOutcomeProbability, __LINE__);
            fGetExpectationValue = (double (*)(void *, const char *))GetFunction("GetExpectationValue");
            CheckFunction((void *)fGetExpectationValue, __LINE__);
 
            fMeasure = (int (*)(void *, int))GetFunction("Measure");
            CheckFunction((void *)fMeasure, __LINE__);
            fMeasureQubits = (long long int (*)(void *, int *, int))GetFunction("MeasureQubits");
            CheckFunction((void *)fMeasureQubits, __LINE__);
 
            fApplyP = (void (*)(void *, int, double))GetFunction("ApplyP");
            CheckFunction((void *)fApplyP, __LINE__);
            fApplyX = (void (*)(void *, int))GetFunction("ApplyX");
            CheckFunction((void *)fApplyX, __LINE__);
            fApplyY = (void (*)(void *, int))GetFunction("ApplyY");
            CheckFunction((void *)fApplyY, __LINE__);
            fApplyZ = (void (*)(void *, int))GetFunction("ApplyZ");
            CheckFunction((void *)fApplyZ, __LINE__);
            fApplyH = (void (*)(void *, int))GetFunction("ApplyH");
            CheckFunction((void *)fApplyH, __LINE__);
            fApplyS = (void (*)(void *, int))GetFunction("ApplyS");
            CheckFunction((void *)fApplyS, __LINE__);
            fApplyT = (void (*)(void *, int))GetFunction("ApplyT");
            CheckFunction((void *)fApplyT, __LINE__);
 
            fApplyRx = (void (*)(void *, int, double))GetFunction("ApplyRx");
            CheckFunction((void *)fApplyRx, __LINE__);
            fApplyRy = (void (*)(void *, int, double))GetFunction("ApplyRy");
            CheckFunction((void *)fApplyRy, __LINE__);
            fApplyRz = (void (*)(void *, int, double))GetFunction("ApplyRz");
            CheckFunction((void *)fApplyRz, __LINE__);
 
            fApplyCS = (void (*)(void *, int, int))GetFunction("ApplyCS");
            CheckFunction((void *)fApplyCS, __LINE__);
            fApplyCT = (void (*)(void *, int, int))GetFunction("ApplyCT");
            CheckFunction((void *)fApplyCT, __LINE__);
            fApplyCH = (void (*)(void *, int, int))GetFunction("ApplyCH");
            CheckFunction((void *)fApplyCH, __LINE__);
            fApplySwap = (void (*)(void *, int, int))GetFunction("ApplySwap");
            CheckFunction((void *)fApplySwap, __LINE__);
            fApplyCX = (void (*)(void *, int, int))GetFunction("ApplyCX");
            CheckFunction((void *)fApplyCX, __LINE__);
            fApplyCY = (void (*)(void *, int, int))GetFunction("ApplyCY");
            CheckFunction((void *)fApplyCY, __LINE__);
            fApplyCZ = (void (*)(void *, int, int))GetFunction("ApplyCZ");
            CheckFunction((void *)fApplyCZ, __LINE__);
 
            fApplyCRx = (void (*)(void *, int, int, double))GetFunction("ApplyCRx");
            CheckFunction((void *)fApplyCRx, __LINE__);
            fApplyCRy = (void (*)(void *, int, int, double))GetFunction("ApplyCRy");
            CheckFunction((void *)fApplyCRy, __LINE__);
            fApplyCRz = (void (*)(void *, int, int, double))GetFunction("ApplyCRz");
            CheckFunction((void *)fApplyCRz, __LINE__);
 
            fApplyCSwap = (void (*)(void *, int, int, int))GetFunction("ApplyCSwap");
            CheckFunction((void *)fApplyCSwap, __LINE__);
            fApplyCCX = (void (*)(void *, int, int, int))GetFunction("ApplyCCX");
            CheckFunction((void *)fApplyCCX, __LINE__);
 
            fApplySdg = (void (*)(void *, int))GetFunction("ApplySdg");
            CheckFunction((void *)fApplySdg, __LINE__);
            fApplyTdg = (void (*)(void *, int))GetFunction("ApplyTdg");
            CheckFunction((void *)fApplyTdg, __LINE__);
            fApplySx = (void (*)(void *, int))GetFunction("ApplySx");
            CheckFunction((void *)fApplySx, __LINE__);
            fApplySxDg = (void (*)(void *, int))GetFunction("ApplySxDg");
            CheckFunction((void *)fApplySxDg, __LINE__);
            fApplyK = (void (*)(void *, int))GetFunction("ApplyK");
            CheckFunction((void *)fApplyK, __LINE__);
 
            fApplyU = (void (*)(void *, int, double, double, double, double))GetFunction("ApplyU");
            CheckFunction((void *)fApplyU, __LINE__);
            fApplyCU = (void (*)(void *, int, int, double, double, double, double))GetFunction("ApplyCU");
            CheckFunction((void *)fApplyCU, __LINE__);
            fApplyCP = (void (*)(void *, int, int, double))GetFunction("ApplyCP");
            CheckFunction((void *)fApplyCP, __LINE__);
            fApplyCSx = (void (*)(void *, int, int))GetFunction("ApplyCSx");
            CheckFunction((void *)fApplyCSx, __LINE__);
            fApplyCSxDg = (void (*)(void *, int, int))GetFunction("ApplyCSxDg");
            CheckFunction((void *)fApplyCSxDg, __LINE__);
 
            fGetAmplitudes = (int (*)(void *, void *, unsigned long long int))GetFunction("GetAmplitudes");
            CheckFunction((void *)fGetAmplitudes, __LINE__);
            fGetAmplitude = (int (*)(void *, long long int, void *, unsigned long long int))GetFunction("GetAmplitude");
            CheckFunction((void *)fGetAmplitude, __LINE__);
            fIsDoublePrecision = (int (*)())GetFunction("IsDoublePrecision");
            CheckFunction((void *)fIsDoublePrecision, __LINE__);
 
            if (fInitialize)
            {
                fInitialize();
                initialized = true;
                return true;
            }
        }
 
        return false;
    }
 
    static void CheckFunction(void *func, int line) noexcept
    {
        if (!func)
        {
            std::cerr << "QuestLibSim: Unable to load function, line #: " << line;
 
#ifdef __linux__
            const char *dlsym_error = dlerror();
            if (dlsym_error)
                std::cerr << ", error: " << dlsym_error;
#elif defined(_WIN32)
            const DWORD error = GetLastError();
            std::cerr << ", error code: " << error;
#endif
 
            std::cerr << std::endl;
        }
    }
 
    bool IsValid() const
    {
        return initialized;
    }
 
    // simulator management
 
    unsigned long int CreateSimulator(int nrQubits)
    {
        if (initialized)
            return fCreateSimulator(nrQubits);
        else
            throw std::runtime_error("QuestLibSim: Unable to create simulator");
 
        return 0;
    }
 
    void DestroySimulator(unsigned long int simHandle)
    {
        if (initialized)
            fDestroySimulator(simHandle);
        else
            throw std::runtime_error("QuestLibSim: Unable to destroy simulator");
    }
 
    unsigned long int CloneSimulator(void *sim)
    {
        if (initialized)
            return fCloneSimulator(sim);
        else
            throw std::runtime_error("QuestLibSim: Unable to clone simulator");
 
        return 0;
    }
 
    void *GetSimulator(unsigned long int simHandle)
    {
        if (initialized)
            return fGetSimulator(simHandle);
        else
            throw std::runtime_error("QuestLibSim: Unable to get simulator");
 
        return nullptr;
    }
 
    // state query functions
 
    int GetNumQubits(void *sim) const
    {
        if (initialized)
            return fGetNumQubits(sim);
        else
            throw std::runtime_error("QuestLibSim: Unable to get number of qubits");
 
        return 0;
    }
 
    double GetQubitProbability0(void *sim, int qubit) const
    {
        if (initialized)
            return fGetQubitProbability0(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to get qubit probability 0");
 
        return 0;
    }
 
    double GetQubitProbability1(void *sim, int qubit) const
    {
        if (initialized)
            return fGetQubitProbability1(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to get qubit probability 1");
 
        return 0;
    }
 
    double GetOutcomeProbability(void *sim, long long int outcome) const
    {
        if (initialized)
            return fGetOutcomeProbability(sim, outcome);
        else
            throw std::runtime_error("QuestLibSim: Unable to get outcome probability");
 
        return 0;
    }
 
    double GetExpectationValue(void *sim, const char *pauliStr) const
    {
        if (initialized)
            return fGetExpectationValue(sim, pauliStr);
        else
            throw std::runtime_error("QuestLibSim: Unable to get expectation value");
 
        return 0;
    }
 
    // measurement functions
 
    int Measure(void *sim, int qubit)
    {
        if (initialized)
            return fMeasure(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to measure qubit");
 
        return 0;
    }
 
    long long int MeasureQubits(void *sim, int *qubits, int numQubits)
    {
        if (initialized)
            return fMeasureQubits(sim, qubits, numQubits);
        else
            throw std::runtime_error("QuestLibSim: Unable to measure qubits");
 
        return 0;
    }
 
    // single-qubit gate functions
 
    void ApplyP(void *sim, int qubit, double angle)
    {
        if (initialized)
            fApplyP(sim, qubit, angle);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply P gate");
    }
 
    void ApplyX(void *sim, int qubit)
    {
        if (initialized)
            fApplyX(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply X gate");
    }
 
    void ApplyY(void *sim, int qubit)
    {
        if (initialized)
            fApplyY(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply Y gate");
    }
 
    void ApplyZ(void *sim, int qubit)
    {
        if (initialized)
            fApplyZ(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply Z gate");
    }
 
    void ApplyH(void *sim, int qubit)
    {
        if (initialized)
            fApplyH(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply H gate");
    }
 
    void ApplyS(void *sim, int qubit)
    {
        if (initialized)
            fApplyS(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply S gate");
    }
 
    void ApplyT(void *sim, int qubit)
    {
        if (initialized)
            fApplyT(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply T gate");
    }
 
    void ApplySdg(void *sim, int qubit)
    {
        if (initialized)
            fApplySdg(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply Sdg gate");
    }
 
    void ApplyTdg(void *sim, int qubit)
    {
        if (initialized)
            fApplyTdg(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply Tdg gate");
    }
 
    void ApplySx(void *sim, int qubit)
    {
        if (initialized)
            fApplySx(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply Sx gate");
    }
 
    void ApplySxDg(void *sim, int qubit)
    {
        if (initialized)
            fApplySxDg(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply SxDg gate");
    }
 
    void ApplyK(void *sim, int qubit)
    {
        if (initialized)
            fApplyK(sim, qubit);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply K gate");
    }
 
    // single-qubit rotation gate functions
 
    void ApplyRx(void *sim, int qubit, double angle)
    {
        if (initialized)
            fApplyRx(sim, qubit, angle);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply Rx gate");
    }
 
    void ApplyRy(void *sim, int qubit, double angle)
    {
        if (initialized)
            fApplyRy(sim, qubit, angle);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply Ry gate");
    }
 
    void ApplyRz(void *sim, int qubit, double angle)
    {
        if (initialized)
            fApplyRz(sim, qubit, angle);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply Rz gate");
    }
 
    void ApplyU(void *sim, int qubit, double theta, double phi, double lambda, double gamma)
    {
        if (initialized)
            fApplyU(sim, qubit, theta, phi, lambda, gamma);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply U gate");
    }
 
    // two-qubit gate functions
 
    void ApplyCS(void *sim, int control, int target)
    {
        if (initialized)
            fApplyCS(sim, control, target);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CS gate");
    }
 
    void ApplyCT(void *sim, int control, int target)
    {
        if (initialized)
            fApplyCT(sim, control, target);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CT gate");
    }
 
    void ApplyCH(void *sim, int control, int target)
    {
        if (initialized)
            fApplyCH(sim, control, target);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CH gate");
    }
 
    void ApplySwap(void *sim, int qubit1, int qubit2)
    {
        if (initialized)
            fApplySwap(sim, qubit1, qubit2);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply Swap gate");
    }
 
    void ApplyCX(void *sim, int control, int target)
    {
        if (initialized)
            fApplyCX(sim, control, target);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CX gate");
    }
 
    void ApplyCY(void *sim, int control, int target)
    {
        if (initialized)
            fApplyCY(sim, control, target);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CY gate");
    }
 
    void ApplyCZ(void *sim, int control, int target)
    {
        if (initialized)
            fApplyCZ(sim, control, target);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CZ gate");
    }
 
    void ApplyCRx(void *sim, int control, int target, double angle)
    {
        if (initialized)
            fApplyCRx(sim, control, target, angle);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CRx gate");
    }
 
    void ApplyCRy(void *sim, int control, int target, double angle)
    {
        if (initialized)
            fApplyCRy(sim, control, target, angle);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CRy gate");
    }
 
    void ApplyCRz(void *sim, int control, int target, double angle)
    {
        if (initialized)
            fApplyCRz(sim, control, target, angle);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CRz gate");
    }
 
    void ApplyCP(void *sim, int control, int target, double angle)
    {
        if (initialized)
            fApplyCP(sim, control, target, angle);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CP gate");
    }
 
    void ApplyCU(void *sim, int control, int target, double theta, double phi, double lambda, double gamma)
    {
        if (initialized)
            fApplyCU(sim, control, target, theta, phi, lambda, gamma);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CU gate");
    }
 
    void ApplyCSx(void *sim, int control, int target)
    {
        if (initialized)
            fApplyCSx(sim, control, target);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CSx gate");
    }
 
    void ApplyCSxDg(void *sim, int control, int target)
    {
        if (initialized)
            fApplyCSxDg(sim, control, target);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CSxDg gate");
    }
 
    // three-qubit gate functions
 
    void ApplyCSwap(void *sim, int control, int qubit1, int qubit2)
    {
        if (initialized)
            fApplyCSwap(sim, control, qubit1, qubit2);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CSwap gate");
    }
 
    void ApplyCCX(void *sim, int control1, int control2, int target)
    {
        if (initialized)
            fApplyCCX(sim, control1, control2, target);
        else
            throw std::runtime_error("QuestLibSim: Unable to apply CCX gate");
    }
 
    // amplitude functions
 
    bool GetAmplitudes(void *sim, std::vector<std::complex<double>> &amplitudes) const
    {
        if (initialized)
        {
            if (IsDoublePrecision())
                return fGetAmplitudes(sim, amplitudes.data(), amplitudes.size() * sizeof(std::complex<double>)) == 1;
            else
            {
                std::vector<std::complex<float>> amplitudesSingle(amplitudes.size());
                if (fGetAmplitudes(sim, amplitudesSingle.data(), amplitudesSingle.size() * sizeof(std::complex<float>)) == 1)
                {
                    for (size_t i = 0; i < amplitudes.size(); ++i)
                        amplitudes[i] = std::complex<double>(static_cast<double>(amplitudesSingle[i].real()), static_cast<double>(amplitudesSingle[i].imag()));
 
                    return true;
                }
            }
        }
        else
            throw std::runtime_error("QuestLibSim: Unable to get amplitudes");
 
        return false;
    }
 
    bool GetAmplitude(void *sim, long long int index, std::complex<double> &amplitude) const
    {
        if (initialized)
        {
            if (IsDoublePrecision())
                return fGetAmplitude(sim, index, &amplitude, sizeof(std::complex<double>)) == 1;
            else
            {
                std::complex<float> ampSingle;
                if (fGetAmplitude(sim, index, &ampSingle, sizeof(std::complex<float>)) == 1)
                {
                    amplitude = std::complex<double>(static_cast<double>(ampSingle.real()), static_cast<double>(ampSingle.imag()));
                    return true;
                }
            }
        }
        else
            throw std::runtime_error("QuestLibSim: Unable to get amplitude");
        return false;
    }
 
    bool IsDoublePrecision() const
    {
        if (initialized)
            return fIsDoublePrecision() == 1;
        else
            throw std::runtime_error("QuestLibSim: Unable to check double precision");
        return false;
    }
 
  private:
    bool initialized = false;
 
    void (*fInitialize)() = nullptr;
    void (*fFinalize)() = nullptr;
 
    unsigned long int (*fCreateSimulator)(int) = nullptr;
    void (*fDestroySimulator)(unsigned long int) = nullptr;
    unsigned long int (*fCloneSimulator)(void *) = nullptr;
    void *(*fGetSimulator)(unsigned long int) = nullptr;
 
    int (*fGetNumQubits)(void *) = nullptr;
    double (*fGetQubitProbability0)(void *, int) = nullptr;
    double (*fGetQubitProbability1)(void *, int) = nullptr;
    double (*fGetOutcomeProbability)(void *, long long int) = nullptr;
    double (*fGetExpectationValue)(void *, const char *) = nullptr;
 
    int (*fMeasure)(void *, int) = nullptr;
    long long int (*fMeasureQubits)(void *, int *, int) = nullptr;
 
    void (*fApplyP)(void *, int, double) = nullptr;
    void (*fApplyX)(void *, int) = nullptr;
    void (*fApplyY)(void *, int) = nullptr;
    void (*fApplyZ)(void *, int) = nullptr;
    void (*fApplyH)(void *, int) = nullptr;
    void (*fApplyS)(void *, int) = nullptr;
    void (*fApplyT)(void *, int) = nullptr;
    void (*fApplyRx)(void *, int, double) = nullptr;
    void (*fApplyRy)(void *, int, double) = nullptr;
    void (*fApplyRz)(void *, int, double) = nullptr;
 
    void (*fApplyCS)(void *, int, int) = nullptr;
    void (*fApplyCT)(void *, int, int) = nullptr;
    void (*fApplyCH)(void *, int, int) = nullptr;
    void (*fApplySwap)(void *, int, int) = nullptr;
    void (*fApplyCX)(void *, int, int) = nullptr;
    void (*fApplyCY)(void *, int, int) = nullptr;
    void (*fApplyCZ)(void *, int, int) = nullptr;
    void (*fApplyCRx)(void *, int, int, double) = nullptr;
    void (*fApplyCRy)(void *, int, int, double) = nullptr;
    void (*fApplyCRz)(void *, int, int, double) = nullptr;
 
    void (*fApplyCSwap)(void *, int, int, int) = nullptr;
    void (*fApplyCCX)(void *, int, int, int) = nullptr;
 
    void (*fApplySdg)(void *, int) = nullptr;
    void (*fApplyTdg)(void *, int) = nullptr;
    void (*fApplySx)(void *, int) = nullptr;
    void (*fApplySxDg)(void *, int) = nullptr;
    void (*fApplyK)(void *, int) = nullptr;
 
    void (*fApplyU)(void *, int, double, double, double, double) = nullptr;
    void (*fApplyCU)(void *, int, int, double, double, double, double) = nullptr;
    void (*fApplyCP)(void *, int, int, double) = nullptr;
    void (*fApplyCSx)(void *, int, int) = nullptr;
    void (*fApplyCSxDg)(void *, int, int) = nullptr;
    int (*fGetAmplitudes)(void *, void *, unsigned long long int) = nullptr;
    int (*fGetAmplitude)(void *, long long int, void *, unsigned long long int) = nullptr;
    int (*fIsDoublePrecision)() = nullptr;
};
 
} // namespace Simulators
 
#endif // _QUEST_LIB_SIM_H_