GpuSimulator.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _GPUSIMULATOR_H
#define _GPUSIMULATOR_H
 
#ifdef INCLUDED_BY_FACTORY
 
#ifdef __linux__
 
#include "GpuState.h"
 
namespace Simulators {
// TODO: Maybe use the pimpl idiom
// https://en.cppreference.com/w/cpp/language/pimpl to hide the implementation
// for good but during development this should be good enough
namespace Private {

class GpuSimulator : public GpuState {
public:
  GpuSimulator() = default;
  // allow no copy or assignment
  GpuSimulator(const GpuSimulator &) = delete;
  GpuSimulator &operator=(const GpuSimulator &) = delete;
 
  // but allow moving
  GpuSimulator(GpuSimulator &&other) = default;
  GpuSimulator &operator=(GpuSimulator &&other) = default;

  void ApplyP(Types::qubit_t qubit, double lambda) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyP(qubit, lambda);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyP(qubit, lambda);
 
    NotifyObservers({qubit});
  }

  void ApplyX(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyX(qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyX(qubit);
 
    NotifyObservers({qubit});
  }

  void ApplyY(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyY(qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyY(qubit);
 
    NotifyObservers({qubit});
  }

  void ApplyZ(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyZ(qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyZ(qubit);
 
    NotifyObservers({qubit});
  }

  void ApplyH(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyH(qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyH(qubit);
 
    NotifyObservers({qubit});
  }

  void ApplyS(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyS(qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyS(qubit);
 
    NotifyObservers({qubit});
  }

  void ApplySDG(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplySDG(qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplySDG(qubit);
 
    NotifyObservers({qubit});
  }

  void ApplyT(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyT(qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyT(qubit);
 
    NotifyObservers({qubit});
  }

  void ApplyTDG(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyTDG(qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyTDG(qubit);
 
    NotifyObservers({qubit});
  }

  void ApplySx(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplySX(qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplySX(qubit);
 
    NotifyObservers({qubit});
  }

  void ApplySxDAG(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplySXDG(qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplySXDG(qubit);
 
    NotifyObservers({qubit});
  }

  void ApplyK(Types::qubit_t qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyK(qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyK(qubit);
 
    NotifyObservers({qubit});
  }

  void ApplyRx(Types::qubit_t qubit, double theta) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyRx(qubit, theta);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyRx(qubit, theta);
 
    NotifyObservers({qubit});
  }

  void ApplyRy(Types::qubit_t qubit, double theta) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyRy(qubit, theta);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyRy(qubit, theta);
 
    NotifyObservers({qubit});
  }

  void ApplyRz(Types::qubit_t qubit, double theta) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyRz(qubit, theta);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyRz(qubit, theta);
 
    NotifyObservers({qubit});
  }

  void ApplyU(Types::qubit_t qubit, double theta, double phi, double lambda,
              double gamma) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyU(qubit, theta, phi, lambda, gamma);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyU(qubit, theta, phi, lambda, gamma);
 
    NotifyObservers({qubit});
  }

  void ApplyCX(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCX(ctrl_qubit, tgt_qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyCX(ctrl_qubit, tgt_qubit);
 
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCY(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCY(ctrl_qubit, tgt_qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyCY(ctrl_qubit, tgt_qubit);
 
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCZ(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCZ(ctrl_qubit, tgt_qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyCZ(ctrl_qubit, tgt_qubit);
 
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCP(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
               double lambda) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCP(ctrl_qubit, tgt_qubit, lambda);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyCP(ctrl_qubit, tgt_qubit, lambda);
 
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCRx(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
                double theta) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCRx(ctrl_qubit, tgt_qubit, theta);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyCRx(ctrl_qubit, tgt_qubit, theta);
 
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCRy(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
                double theta) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCRy(ctrl_qubit, tgt_qubit, theta);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyCRy(ctrl_qubit, tgt_qubit, theta);
 
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCRz(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
                double theta) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCRz(ctrl_qubit, tgt_qubit, theta);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyCRz(ctrl_qubit, tgt_qubit, theta);
 
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCH(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCH(ctrl_qubit, tgt_qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyCH(ctrl_qubit, tgt_qubit);
 
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCSx(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCSX(ctrl_qubit, tgt_qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyCSX(ctrl_qubit, tgt_qubit);
 
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyCSxDAG(Types::qubit_t ctrl_qubit,
                   Types::qubit_t tgt_qubit) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCSXDG(ctrl_qubit, tgt_qubit);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyCSXDG(ctrl_qubit, tgt_qubit);
 
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplySwap(Types::qubit_t qubit0, Types::qubit_t qubit1) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplySwap(qubit0, qubit1);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplySwap(qubit0, qubit1);
 
    NotifyObservers({qubit1, qubit0});
  }

  void ApplyCCX(Types::qubit_t qubit0, Types::qubit_t qubit1,
                Types::qubit_t qubit2) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCCX(qubit0, qubit1, qubit2);
    else if (GetSimulationType() == SimulationType::kMatrixProductState) {
      const size_t q1 = qubit0; // control 1
      const size_t q2 = qubit1; // control 2
      const size_t q3 = qubit2; // target
 
      // Sleator-Weinfurter decomposition
      mps->ApplyCSX(static_cast<unsigned int>(q2),
                    static_cast<unsigned int>(q3));
      mps->ApplyCX(static_cast<unsigned int>(q1),
                   static_cast<unsigned int>(q2));
      mps->ApplyCSXDG(static_cast<unsigned int>(q2),
                      static_cast<unsigned int>(q3));
      mps->ApplyCX(static_cast<unsigned int>(q1),
                   static_cast<unsigned int>(q2));
      mps->ApplyCSX(static_cast<unsigned int>(q1),
                    static_cast<unsigned int>(q3));
    }
 
    NotifyObservers({qubit2, qubit1, qubit0});
  }

  void ApplyCSwap(Types::qubit_t ctrl_qubit, Types::qubit_t qubit0,
                  Types::qubit_t qubit1) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCSwap(ctrl_qubit, qubit0, qubit1);
    else if (GetSimulationType() == SimulationType::kMatrixProductState) {
      const size_t q1 = ctrl_qubit; // control
      const size_t q2 = qubit0;
      const size_t q3 = qubit1;
 
      // TODO: find a better decomposition
      // this one I've got with the qiskit transpiler
      mps->ApplyCX(static_cast<unsigned int>(q3),
                   static_cast<unsigned int>(q2));
      mps->ApplyCSX(static_cast<unsigned int>(q2),
                    static_cast<unsigned int>(q3));
      mps->ApplyCX(static_cast<unsigned int>(q1),
                   static_cast<unsigned int>(q2));
 
      mps->ApplyP(static_cast<unsigned int>(q3), M_PI);
      mps->ApplyP(static_cast<unsigned int>(q2), -M_PI_2);
 
      mps->ApplyCSX(static_cast<unsigned int>(q2),
                    static_cast<unsigned int>(q3));
      mps->ApplyCX(static_cast<unsigned int>(q1),
                   static_cast<unsigned int>(q2));
 
      mps->ApplyP(static_cast<unsigned int>(q3), M_PI);
 
      mps->ApplyCSX(static_cast<unsigned int>(q1),
                    static_cast<unsigned int>(q3));
      mps->ApplyCX(static_cast<unsigned int>(q3),
                   static_cast<unsigned int>(q2));
    }
 
    NotifyObservers({qubit1, qubit0, ctrl_qubit});
  }

  void ApplyCU(Types::qubit_t ctrl_qubit, Types::qubit_t tgt_qubit,
               double theta, double phi, double lambda, double gamma) override {
    if (GetSimulationType() == SimulationType::kStatevector)
      state->ApplyCU(ctrl_qubit, tgt_qubit, theta, phi, lambda, gamma);
    else if (GetSimulationType() == SimulationType::kMatrixProductState)
      mps->ApplyCU(ctrl_qubit, tgt_qubit, theta, phi, lambda, gamma);
 
    NotifyObservers({tgt_qubit, ctrl_qubit});
  }

  void ApplyNop() override {
    // do nothing
  }

  std::unique_ptr<ISimulator> Clone() override {
    auto cloned = std::make_unique<GpuSimulator>();
 
    cloned->simulationType = simulationType;
    cloned->nrQubits = nrQubits;
 
    cloned->limitSize = limitSize;
    cloned->limitEntanglement = limitEntanglement;
    cloned->chi = chi;
    cloned->singularValueThreshold = singularValueThreshold;
 
    if (state)
      cloned->state = state->Clone();
    else if (mps)
      cloned->mps = mps->Clone();
 
    return cloned;
  }
};
 
} // namespace Private
} // namespace Simulators
 
#endif
#endif
#endif