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 = {}) : Random(ind, GenerateSeed())
    {
        explicitlySeeded = false;
    }

    Random(const std::vector<size_t> &ind, size_t seed, 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;
        explicitlySeeded = true;
        std::seed_seq seed{uint32_t(s & 0xffffffff), uint32_t(s >> 32)};
        rng.seed(seed);
    }
 
    bool HasExplicitSeed() const
    {
        return explicitlySeeded;
    }

    std::shared_ptr<IOperation<Time>> Clone() const override
    {
        auto copy = std::make_shared<Random<Time>>(GetBitsIndices(), s, IOperation<Time>::GetDelay());
        copy->explicitlySeeded = explicitlySeeded;
        return copy;
    }

    std::shared_ptr<Random<Time>> CloneForExecution(uint64_t stream, uint64_t defaultSeed = 0) const
    {
        auto copy = std::static_pointer_cast<Random<Time>>(Clone());
        copy->Seed(Simulators::IState::DeriveSeed(explicitlySeeded ? s : defaultSeed, stream));
        return copy;
    }

    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:
    static size_t GenerateSeed()
    {
        std::random_device entropy;
        return std::uniform_int_distribution<size_t>{}(entropy);
    }
 
    std::vector<size_t> indices;                   
    mutable std::mt19937_64 rng;                   
    mutable std::bernoulli_distribution dist_bool; 
    size_t s;                                      
    bool explicitlySeeded = false;
};
 
} // namespace Circuits
 
#endif // !_RANDOM_OP_H_