class QPanda::PickUpNodes

Overview

Pick Up all the Nodes between the two NodeIters. More…

#include <QCircuitInfo.h>

class PickUpNodes: public QPanda::TraverseByNodeIter
{
public:
    // construction

    PickUpNodes(
        QProg& output_prog,
        QProg src_prog,
        const std::vector<NodeType>& reject_node_types,
        const NodeIter& node_itr_start,
        const NodeIter& node_itr_end
        );

    // methods

    virtual void traverse_qprog();

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void setDaggerFlag(bool b);
    void reverse_dagger_circuit();
    static bool check_control_qubits(QGate& gate);
    static void no_dagger_gate(QGate& gate);
};

Inherited Members

public:
    // methods

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

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);

Detailed Documentation

Pick Up all the Nodes between the two NodeIters.

Construction

PickUpNodes(
    QProg& output_prog,
    QProg src_prog,
    const std::vector<NodeType>& reject_node_types,
    const NodeIter& node_itr_start,
    const NodeIter& node_itr_end
    )

Constructor of PickUpNodes.

Methods

void setDaggerFlag(bool b)

set dagger flag

Parameters:

bool

void reverse_dagger_circuit()

reverse the dagger circuit

static bool check_control_qubits(QGate& gate)

check whether the control qubit is same as the target qubit

Returns:

bool return true if the control qubit is same as the target qubit, otherwise return false

static void no_dagger_gate(QGate& gate)

check no dagger gate