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_