Measurements.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _MEASUREMENTS_H_
#define _MEASUREMENTS_H_
 
#include "Operations.h"
#include <vector>
 
namespace Circuits {

template <typename Time = Types::time_type>
class MeasurementOperation : public IOperation<Time> {
public:
  MeasurementOperation(
      const std::vector<std::pair<Types::qubit_t, size_t>> &qs = {},
      Time delay = 0)
      : IOperation<Time>(delay) {
    SetQubits(qs);
  }

  OperationType GetType() const override { return OperationType::kMeasurement; }

  virtual size_t GetNumQubits() const { return qubits.size(); }

  void Clear() {
    qubits.clear();
    bits.clear();
  }

  void SetQubits(const std::vector<std::pair<Types::qubit_t, size_t>> &qs) {
    qubits.resize(qs.size());
    bits.resize(qs.size());
    for (size_t i = 0; i < qs.size(); ++i) {
      qubits[i] = qs[i].first;
      bits[i] = qs[i].second;
    }
  }

  const Types::qubits_vector &GetQubits() const { return qubits; }

  const std::vector<size_t> &GetBitsIndices() const { return bits; }

  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    if (qubits.empty())
      return;
 
    size_t res = sim->Measure(qubits);
 
    for (size_t i = 0; i < qubits.size(); ++i) {
      state.SetBit(bits[i], (res & 1) != 0);
      res >>= 1;
    }
  }

  void Sample(const std::shared_ptr<Simulators::ISimulator> &sim,
              OperationState &state) const {
    if (qubits.empty())
      return;
 
    size_t res = sim->SampleCounts(qubits, 1).begin()->first;
 
    for (auto bit : bits) {
      state.SetBit(bit, (res & 1) != 0);
      res >>= 1;
    }
  }
 
  void SetStateFromSample(size_t measurements, OperationState &state) const {
    if (qubits.empty())
      return;
 
    for (size_t index = 0; index < qubits.size(); ++index) {
      const auto cbit = bits[index];
      const size_t qubitMask = 1ULL << index;
      state.SetBit(cbit, (measurements & qubitMask) != 0);
    }
  }
 
  void SetStateFromAllMeasurements(size_t allMeasurements,
                                   OperationState &state) const {
    if (qubits.empty())
      return;
 
    for (size_t index = 0; index < qubits.size(); ++index) {
      const auto q = qubits[index];
      const auto cbit = bits[index];
 
      const size_t qubitMask = 1ULL << q;
 
      state.SetBit(cbit, (allMeasurements & qubitMask) != 0);
    }
  }

  std::shared_ptr<IOperation<Time>> Clone() const override {
    std::vector<std::pair<Types::qubit_t, size_t>> qs(qubits.size());
    for (size_t i = 0; i < qubits.size(); ++i)
      qs[i] = std::make_pair(qubits[i], bits[i]);
 
    return std::make_shared<MeasurementOperation<Time>>(
        qs, IOperation<Time>::GetDelay());
  }

  Types::qubits_vector AffectedQubits() const override { return qubits; }

  std::vector<size_t> AffectedBits() const override { return GetBitsIndices(); }

  std::shared_ptr<IOperation<Time>>
  Remap(const std::unordered_map<Types::qubit_t, Types::qubit_t> &qubitsMap,
        const std::unordered_map<Types::qubit_t, Types::qubit_t> &bitsMap = {})
      const override {
    auto newOp = this->Clone();
 
    for (size_t i = 0; i < qubits.size(); ++i) {
      const auto qubitit = qubitsMap.find(qubits[i]);
      if (qubitit != qubitsMap.end())
        std::static_pointer_cast<MeasurementOperation<Time>>(newOp)->SetQubit(
            i, qubitit->second);
      // else throw std::runtime_error("MeasurementOperation::Remap: qubit not
      // found in map.");
    }
 
    for (size_t i = 0; i < bits.size(); ++i) {
      const auto bitit = bitsMap.find(bits[i]);
      if (bitit != bitsMap.end())
        std::static_pointer_cast<MeasurementOperation<Time>>(newOp)->SetBit(
            i, bitit->second);
      // else throw std::runtime_error("MeasurementOperation::Remap: bit not
      // found in map.");
    }
 
    return newOp;
  }

  bool IsClifford() const override { return true; }

  void SetQubit(size_t index, Types::qubit_t qubit) {
    if (index < qubits.size())
      qubits[index] = qubit;
  }

  void SetBit(size_t index, Types::qubit_t bit) {
    if (index < bits.size())
      bits[index] = bit;
  }
 
private:
  Types::qubits_vector qubits; 
  std::vector<size_t>
      bits; 
};
 
} // namespace Circuits
 
#endif // !_MEASUREMENTS_H_