SimpleHost.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _SIMPLE_HOST_H_
#define _SIMPLE_HOST_H_
 
#include <numeric>
 
#include "Host.h"
#include "Network.h"
 
namespace Network {
 
template <typename Time = Types::time_type>
class SimpleHost : public IHost<Time> {
 public:
  SimpleHost(size_t hostId, size_t startQubitId, size_t numQubits,
             size_t startClassicalBitId, size_t numClassicalBits)
      : id(hostId),
        startQubitId(startQubitId),
        numQubits(numQubits),
        startClassicalBitId(startClassicalBitId),
        numClassicalBits(numClassicalBits) {}
 
  size_t GetId() const override { return id; }
 
  size_t GetNumQubits() const override { return numQubits; }
 
  size_t GetNumNetworkEntangledQubits() const override {
    if (std::numeric_limits<size_t>::max() == entangledQubitId) return 0;
 
    return 1;
  }
 
  size_t GetNumClassicalBits() const override { return numClassicalBits; }
 
  bool IsQubitOnHost(size_t qubitId) const override {
    return qubitId >= startQubitId && qubitId < startQubitId + numQubits;
  }
 
  bool AreQubitsOnSameHost(size_t qubitId1, size_t qubitId2) const override {
    return IsQubitOnHost(qubitId1) && IsQubitOnHost(qubitId2);
  }
 
  bool IsClassicalBitOnHost(size_t cbitId) const override {
    return (cbitId >= startClassicalBitId &&
            cbitId < startClassicalBitId + numClassicalBits) ||
           cbitId == entangledQubitMeasurementBit;
  }
 
  bool IsEntangledQubitOnHost(size_t qubitId) const override {
    if (GetNumNetworkEntangledQubits() == 0) return false;
 
    return qubitId == entangledQubitId;
  }
 
  bool AreCbitsOnSameHost(size_t cbitId1, size_t cbitId2) const override {
    return IsClassicalBitOnHost(cbitId1) && IsClassicalBitOnHost(cbitId2);
  }
 
  std::vector<size_t> GetQubitsIds() const override {
    std::vector<size_t> res(numQubits);
 
    std::iota(res.begin(), res.end(), startQubitId);
 
    return res;
  }
 
  std::vector<size_t> GetNetworkEntangledQubitsIds() const override {
    if (GetNumNetworkEntangledQubits() == 0) return {};
 
    return {entangledQubitId};
  }
 
  std::vector<size_t> GetClassicalBitsIds() const override {
    std::vector<size_t> res(numClassicalBits);
 
    std::iota(res.begin(), res.end(), startClassicalBitId);
 
    return res;
  }
 
  std::vector<size_t> GetEntangledQubitMeasurementBitIds() const override {
    if (std::numeric_limits<size_t>::max() == entangledQubitMeasurementBit)
      return {};
 
    return {entangledQubitMeasurementBit};
  }
 
  bool SendPacketToHost(size_t hostId,
                        const std::vector<uint8_t> &packet) override {
    return false;
  }
 
  bool RecvPacketFromHost(size_t hostId,
                          const std::vector<uint8_t> &packet) override {
    return false;
  }
 
  size_t GetStartQubitId() const override { return startQubitId; }
 
  size_t GetStartClassicalBitId() const override { return startClassicalBitId; }
 
  void SetEntangledQubitId(size_t id) { entangledQubitId = id; }
 
  void SetEntangledQubitMeasurementBit(size_t id) {
    entangledQubitMeasurementBit = id;
  }
 
 private:
  size_t id; 
  size_t startQubitId =
      0;                
  size_t numQubits = 0; 
  size_t startClassicalBitId =
      0; 
  size_t numClassicalBits =
      0; 
  size_t entangledQubitId =
      std::numeric_limits<size_t>::max(); 
  size_t entangledQubitMeasurementBit =
      std::numeric_limits<size_t>::max(); 
};
 
}  // namespace Network
 
#endif  // ! _SIMPLE_HOST_H_