State.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _SIMULATOR_STATE_H_
#define _SIMULATOR_STATE_H_
 
#include <Eigen/Eigen>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#ifndef NO_QISKIT_AER
#include "framework/linalg/vector.hpp"
#endif
 
#include "SimulatorObserver.h"
 
namespace Simulators {

/*
template<class T> class avoid_init_allocator : public std::allocator<T>
{
public:
        using std::allocator<T>::allocator;
 
        template <class U, class... Args> void construct(U*, Args&&...) {}
};
*/

enum class SimulatorType : int {
#ifndef NO_QISKIT_AER
  kQiskitAer, 
#endif
  kQCSim, 
#ifndef NO_QISKIT_AER
  kCompositeQiskitAer, 
#endif
  kCompositeQCSim 
#ifdef __linux__
  ,
  kGpuSim 
#endif
};

enum class SimulationType : int {
  kStatevector,        
  kMatrixProductState, 
  kStabilizer,         
  kTensorNetwork,      
  kOther 
};

class IState {
public:
  virtual ~IState() = default;

  virtual void Initialize() = 0;

  virtual void
  InitializeState(size_t num_qubits,
                  std::vector<std::complex<double>> &amplitudes) = 0;

#ifndef NO_QISKIT_AER
  virtual void
  InitializeState(size_t num_qubits,
                  AER::Vector<std::complex<double>> &amplitudes) = 0;
#endif

  virtual void InitializeState(size_t num_qubits,
                               Eigen::VectorXcd &amplitudes) = 0;

  virtual void Reset() = 0;

  virtual void Configure(const char *key, const char *value) = 0;

  virtual std::string GetConfiguration(const char *key) const = 0;

  virtual size_t AllocateQubits(size_t num_qubits) = 0;

  virtual size_t GetNumberOfQubits() const = 0;

  virtual void Clear() = 0;

  virtual size_t Measure(const Types::qubits_vector &qubits) = 0;

  virtual void ApplyReset(const Types::qubits_vector &qubits) = 0;

  virtual double Probability(Types::qubit_t outcome) = 0;

  virtual std::complex<double> Amplitude(Types::qubit_t outcome) = 0;

  virtual std::vector<double> AllProbabilities() = 0;

  virtual std::vector<double>
  Probabilities(const Types::qubits_vector &qubits) = 0;

  virtual std::unordered_map<Types::qubit_t, Types::qubit_t>
  SampleCounts(const Types::qubits_vector &qubits, size_t shots = 1000) = 0;

  virtual double ExpectationValue(const std::string &pauliString) = 0;

  void RegisterObserver(const std::shared_ptr<ISimulatorObserver> &observer) {
    observers.insert(observer);
  }

  void UnregisterObserver(const std::shared_ptr<ISimulatorObserver> &observer) {
    observers.erase(observer);
  }

  void ClearObservers() { observers.clear(); }

  virtual SimulatorType GetType() const = 0;

  virtual SimulationType GetSimulationType() const = 0;

  virtual void Flush() = 0;

  virtual void SaveStateToInternalDestructive() = 0;

  virtual void RestoreInternalDestructiveSavedState() = 0;

  virtual void SaveState() = 0;

  virtual void RestoreState() = 0;

  virtual std::complex<double> AmplitudeRaw(Types::qubit_t outcome) = 0;

  virtual void SetMultithreading(bool multithreading = true) = 0;

  virtual bool GetMultithreading() const = 0;

  virtual bool IsQcsim() const = 0;

  virtual Types::qubit_t MeasureNoCollapse() = 0;
 
protected:
  void DontNotify() { notifyObservers = false; }

  void Notify() { notifyObservers = true; }

  void NotifyObservers(const Types::qubits_vector &affectedQubits) {
    if (!notifyObservers)
      return;
 
    for (auto &observer : observers) {
      observer->Update(affectedQubits);
    }
  }
 
private:
  std::unordered_set<std::shared_ptr<ISimulatorObserver>>
      observers; 
  bool notifyObservers =
      true; 
};
 
} // namespace Simulators
 
#endif // !_SIMULATOR_STATE_H_