class QPanda::SingleAmplitudeQVM

Overview

Quantum machine for single amplitude simulation. More…

#include <SingleAmplitudeQVM.h>

class SingleAmplitudeQVM:
    public QPanda::QVM,
    public QPanda::TraversalInterface
{
public:
    // methods

    virtual void init();
    void run(QProg& prog, QVec& qv, size_t max_rank = 30, size_t alloted_time = 5);
    void run(QProg& prog, QVec& qv, size_t max_rank, const std::vector<qprog_sequence_t>& sequences);
    size_t getSequence(const std::vector<size_t>& quickbb_vertice, std::vector<qprog_sequence_t>& sequence_vec);
    void getQuickMapVertice(std::vector<std::pair<size_t, size_t>>& map_vector);
    qstate_type pMeasureBinindex(std::string index);
    qstate_type pMeasureDecindex(std::string index);
    prob_dict getProbDict(QVec qlist);
    prob_dict probRunDict(QProg& prog, QVec qlist);
    prob_dict getProbDict(const std::vector<int>& qaddrs_list);

    prob_dict probRunDict(
        QProg& prog,
        const std::vector<int>& qaddrs_list
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );
};

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 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

Quantum machine for single amplitude simulation.

See also:

QuantumMachine

Methods

virtual void init()

init

Returns:

void

void run(QProg& prog, QVec& qv, size_t max_rank = 30, size_t alloted_time = 5)

run

Parameters:

QProg&	quantum program
QVec&	qubits vector
size_t	rank number
size_t	run QuickBB alloted time

void run(QProg& prog, QVec& qv, size_t max_rank, const std::vector<qprog_sequence_t>& sequences)

run

Parameters:

QProg&	quantum program
QVec&	qubits vector
size_t	rank number
size_t	quantum program contraction sequence

size_t getSequence(
    const std::vector<size_t>& quickbb_vertice,
    std::vector<qprog_sequence_t>& sequence_vec
    )

get quantum program contraction sequence

Parameters:

const	std::vector<size_t>& quickbb vertice
std::vector<qprog_sequence_t>&	quantum program contraction sequence

Returns:

size_t sequence number

qstate_type pMeasureBinindex(std::string index)

PMeasure by binary index.

example: pMeasureBinindex(“0000000000”)

Parameters:

std::string

binary index

Returns:

qstate_type double

qstate_type pMeasureDecindex(std::string index)

PMeasure by decimal index.

example: pMeasureDecindex(“1”)

Parameters:

std::string

decimal index

Returns:

qstate_type double

prob_dict getProbDict(QVec qlist)

get probability by qubits

Parameters:

const

QVec & qubits vector

Returns:

prob_dict

prob_dict probRunDict(QProg& prog, QVec qlist)

get probability by qubits

Parameters:

QProg&	quantum program
QVec&	qubits vector

Returns:

prob_dict