Delay.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _CIRCUIT_DELAY_H_
#define _CIRCUIT_DELAY_H_
 
#include "Operations.h"
#include <cmath>
#include <stdexcept>
 
namespace Circuits
{

template <typename Time = Types::time_type> class Delay : public IOperation<Time>
{
  public:
    Delay(Types::qubit_t qubit = 0, Time duration = 0) : IOperation<Time>(duration), qubit_(qubit)
    {
        ValidateDuration(duration);
    }

    void Execute(const std::shared_ptr<Simulators::ISimulator> &sim, OperationState &state) const override
    {
        (void)sim;
        (void)state;
    }

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

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

    Types::qubit_t GetQubit() const
    {
        return qubit_;
    }

    void SetQubit(Types::qubit_t q)
    {
        qubit_ = q;
    }

    Time GetDuration() const
    {
        return IOperation<Time>::GetDelay();
    }

    void SetDuration(Time d)
    {
        ValidateDuration(d);
        IOperation<Time>::SetDelay(d);
    }

    void SetDelay(Time d) override
    {
        SetDuration(d);
    }
 
    bool CanAffectQuantumState() const override
    {
        return false;
    }
 
    bool IsClifford() const override
    {
        return true;
    }
 
    std::shared_ptr<IOperation<Time>> Clone() const override
    {
        return std::make_shared<Delay<Time>>(qubit_, GetDuration());
    }
 
    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
    {
        (void)bitsMap;
        Types::qubit_t mappedQubit = qubit_;
        const auto it = qubitsMap.find(qubit_);
        if (it != qubitsMap.end())
            mappedQubit = it->second;
        return std::make_shared<Delay<Time>>(mappedQubit, GetDuration());
    }
 
  private:
    static void ValidateDuration(Time d)
    {
        if (std::isnan(static_cast<double>(d)) || std::isinf(static_cast<double>(d)) || d < 0)
        {
            throw std::invalid_argument("Delay duration must be finite and nonnegative");
        }
    }
 
    Types::qubit_t qubit_ = 0;
};
 
} // namespace Circuits
 
#endif // _CIRCUIT_DELAY_H_