RandomOp.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _RANDOM_OP_H_
#define _RANDOM_OP_H_
 
#include "Operations.h"
#include <random>
 
namespace Circuits {
 
template <typename Time = Types::time_type>
class Random : public IOperation<Time> {
 public:
  Random(const std::vector<size_t> &ind = {}, size_t seed = 0, Time delay = 0)
      : IOperation<Time>(delay), indices(ind), s(seed) {
    Seed(seed);
  }
 
  void Execute(const std::shared_ptr<Simulators::ISimulator> &sim,
               OperationState &state) const override {
    for (size_t i : indices) state.SetBit(i, dist_bool(rng));
  }
 
  OperationType GetType() const override { return OperationType::kRandomGen; }
 
  const std::vector<size_t> &GetBitsIndices() const { return indices; }
 
  void SetBitsIndices(const std::vector<size_t> &ind) { indices = ind; }
 
  void Seed(size_t sd) {
    s = sd;
    std::seed_seq seed{uint32_t(s & 0xffffffff), uint32_t(s >> 32)};
    rng.seed(seed);
  }
 
  std::shared_ptr<IOperation<Time>> Clone() const override {
    return std::make_shared<Random<Time>>(GetBitsIndices(), s,
                                          IOperation<Time>::GetDelay());
  }
 
  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 = Clone();
 
    for (size_t i = 0; i < indices.size(); ++i) {
      const auto bitit = bitsMap.find(indices[i]);
      if (bitit != bitsMap.end())
        std::static_pointer_cast<Random<Time>>(newOp)->SetBit(i, bitit->second);
    }
 
    return newOp;
  }
 
  bool IsClifford() const override { return true; }
 
 protected:
  void SetBit(size_t index, Types::qubit_t bit) {
    if (index < indices.size()) indices[index] = bit;
  }
 
 private:
  std::vector<size_t> indices; 
  mutable std::mt19937_64 rng; 
  mutable std::bernoulli_distribution
      dist_bool; 
  size_t s;      
};
 
}  // namespace Circuits
 
#endif  // !_RANDOM_OP_H_