class QPanda::MPSQVM

Overview

MPS quantum virtual machine. More…

#include <MPSQVM.h>

class MPSQVM:
    public QPanda::IdealQVM,
    private QPanda::TraversalInterface
{
public:
    // methods

    virtual void init();

    virtual void initState(
        const QStat& state = {},
        const QVec& qlist = {}
        );

    virtual std::map<std::string, bool> directlyRun(QProg& qProg);

    virtual std::map<std::string, size_t> quickMeasure(
        QVec vQubit,
        size_t shots
        );

    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual QStat getQState();

    virtual prob_tuple pMeasure(
        QVec qubits,
        int select_max = -1
        );

    virtual prob_tuple PMeasure(
        QVec qubits,
        int select_max = -1
        );

    virtual prob_vec PMeasure_no_index(QVec qubits);
    prob_vec pMeasureNoIndex(QVec qubit_vector);

    qcomplex_t pmeasure_bin_index(
        QProg prog,
        std::string str
        );

    qcomplex_t pmeasure_dec_index(
        QProg prog,
        std::string str
        );

    QStat pmeasure_bin_subset(
        QProg prog,
        const std::vector<std::string>& bin_strs
        );

    QStat pmeasure_dec_subset(
        QProg prog,
        const std::vector<std::string>& dec_strs
        );

    virtual prob_tuple getProbTupleList(
        QVec,
        int selectMax = -1
        );

    virtual prob_vec getProbList(
        QVec,
        int selectMax = -1
        );

    virtual prob_dict getProbDict(
        QVec,
        int selectMax = -1
        );

    virtual prob_tuple probRunTupleList(
        QProg&,
        QVec,
        int selectMax = -1
        );

    virtual prob_vec probRunList(
        QProg&,
        QVec,
        int selectMax = -1
        );

    virtual prob_dict probRunDict(
        QProg&,
        QVec,
        int selectMax = -1
        );

    void execute(
        std::shared_ptr<AbstractQGateNode>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractClassicalProg>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumMeasure>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumReset>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumCircuit>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumProgram>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractControlFlowNode>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>&
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>&,
        const std::vector<double>&
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>&,
        const std::vector<QVec>&
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>&,
        const std::vector<double>&,
        const std::vector<QVec>&
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double param
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double param,
        const QVec& qubits_vec
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double param,
        const std::vector<QVec>& qubits_vecs
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double T1,
        double T2,
        double time_param
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double T1,
        double T2,
        double time_param,
        const QVec& qubits_vec
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double T1,
        double T2,
        double time_param,
        const std::vector<QVec>& qubits_vecs
        );

    void set_readout_error(
        const std::vector<std::vector<double>>& readout_params,
        const QVec& qubits
        );

    void set_measure_error(
        NOISE_MODEL model,
        double param
        );

    void set_measure_error(
        NOISE_MODEL model,
        double param,
        const QVec& qubits_vec
        );

    void set_measure_error(
        NOISE_MODEL model,
        double T1,
        double T2,
        double time_param
        );

    void set_measure_error(
        NOISE_MODEL model,
        double T1,
        double T2,
        double time_param,
        const QVec& qubits_vec
        );

    void set_rotation_error(double param);

    void set_reset_error(
        double reset_0_param,
        double reset_1_param
        );
};

Inherited Members

public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {}) = 0;
    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {});
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t);
    virtual QMachineStatus* getStatus() const;
    virtual QResult* getResult();
    virtual std::map<std::string, bool> getResultMap();
    virtual void finalize();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<int>&, int);
    virtual std::map<GateType, size_t> getGateTimeMap() const;
    virtual QStat getQState() const;
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*);
    virtual void set_random_engine(RandomEngine* rng);
    virtual void setConfig(const Configuration& config);
    virtual Qubit* allocateQubit();
    virtual QVec allocateQubits(size_t);
    virtual ClassicalCondition allocateCBit();
    virtual std::vector<ClassicalCondition> allocateCBits(size_t);
    virtual ClassicalCondition allocateCBit(size_t);
    virtual size_t getAllocateQubit();
    virtual size_t getAllocateCMem();
    virtual void Free_Qubit(Qubit*);
    virtual void Free_Qubits(QVec&);
    virtual void Free_CBit(ClassicalCondition&);
    virtual void Free_CBits(std::vector<ClassicalCondition>&);
    virtual void setConfigure(const Configuration&);
    virtual Qubit* qAlloc();
    virtual QVec qAllocMany(size_t qubit_count);
    virtual ClassicalCondition cAlloc();
    virtual ClassicalCondition cAlloc(size_t);
    virtual std::vector<ClassicalCondition> cAllocMany(size_t);
    virtual void qFree(Qubit*);
    virtual void qFreeAll(QVec&);
    virtual void cFree(ClassicalCondition&);
    virtual void cFreeAll(std::vector<ClassicalCondition>&);
    virtual size_t getAllocateQubitNum();
    virtual size_t getAllocateCMemNum();
    virtual size_t get_allocate_qubits(QVec&);
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int);
    virtual prob_vec PMeasure_no_index(QVec qubit_vector) = 0;
    virtual prob_tuple getProbTupleList(QVec, int) = 0;
    virtual prob_vec getProbList(QVec, int) = 0;
    virtual prob_dict getProbDict(QVec, int) = 0;
    virtual prob_tuple probRunTupleList(QProg&, QVec, int) = 0;
    virtual prob_vec probRunList(QProg&, QVec, int) = 0;
    virtual prob_dict probRunDict(QProg&, QVec, int) = 0;
    virtual std::map<std::string, size_t> quickMeasure(QVec, size_t) = 0;
    virtual prob_tuple PMeasure(QVec qubit_vector, int select_max) = 0;
    virtual QStat getQStat() = 0;
    virtual prob_tuple getProbTupleList(QVec, int selectMax = -1);
    virtual prob_vec getProbList(QVec, int selectMax = -1);
    virtual prob_dict getProbDict(QVec, int selectMax = -1);
    virtual prob_tuple probRunTupleList(QProg&, QVec, int selectMax = -1);
    virtual prob_vec probRunList(QProg&, QVec, int selectMax = -1);
    virtual prob_dict probRunDict(QProg&, QVec, int selectMax = -1);
    prob_tuple probRunTupleList(QProg&, const std::vector<int>&, int selectMax = -1);
    prob_vec probRunList(QProg&, const std::vector<int>&, int selectMax = -1);
    prob_dict probRunDict(QProg&, const std::vector<int>&, int selectMax = -1);
    virtual std::map<std::string, size_t> quickMeasure(QVec, size_t);
    virtual QStat getQStat();
    virtual prob_tuple PMeasure(QVec qubit_vector, int select_max);
    virtual prob_vec PMeasure_no_index(QVec qubit_vector);
    QStat getQState();
    prob_tuple pMeasure(QVec qubit_vector, int select_max);
    prob_vec pMeasureNoIndex(QVec qubit_vector);

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

MPS quantum virtual machine.

Methods

virtual void init()

init

Returns:

void

virtual std::map<std::string, bool> directlyRun(QProg& qProg)

directlyRun

Parameters:

QProg&

quantum program

Returns:

std::map<std::string, bool>

virtual std::map<std::string, size_t> runWithConfiguration(
    QProg&,
    std::vector<ClassicalCondition>&,
    int
    )

runWithConfiguration

Parameters:

QProg&	quantum program
std::vector<ClassicalCondition>&
int

Returns:

std::map<std::string, Eigen::size_t>

virtual std::map<std::string, size_t> runWithConfiguration(
    QProg&,
    std::vector<ClassicalCondition>&,
    rapidjson::Document&
    )

runWithConfiguration

Parameters:

QProg&	quantum program
std::vector<ClassicalCondition>&
rapidjson::Document&

Returns:

std::map<std::string, Eigen::size_t>