class QPanda::QCircuitOPtimizer

Overview

#include <QCircuitOptimize.h>

class QCircuitOPtimizer: public QPanda::ProcessOnTraversing
{
public:
    // fields

    QProg m_new_prog;

    // methods

    virtual void process(const bool on_travel_end = false);
    void register_single_gate_optimizer(const int mode);

    void register_optimize_sub_cir(
        QCircuit sub_cir,
        QCircuit replase_to_cir
        );

    void run_optimize(
        QProg src_prog,
        const QVec qubits = {},
        bool b_enable_I = false
        );

    QProg replase_sub_cir(std::function<QCircuit(const size_t)> get_cir_fun);
    void sub_cir_optimizer(const size_t optimizer_sub_cir_index);
    void do_optimizer();
};

Inherited Members

public:
    // typedefs

    typedef TopologSequence<std::pair<size_t, NodeIter>> layer_iter_seq;

    // 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);
    virtual void process(const bool on_travel_end) = 0;
    virtual void run_traversal(QProg src_prog, const QVec qubits = {});
    virtual void do_process(const bool on_travel_end);

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

    virtual void gates_sink_to_topolog_sequence(OptimizerSink& gate_buf, LayeredTopoSeq& seq, const size_t max_output_layer = MAX_LAYER);
    virtual void clean_gate_buf_to_cir(QProg& cir, bool b_clean_all_buf = false);
    virtual void clean_gate_buf(bool b_clean_all_buf = false);
    virtual void drop_gates(const size_t max_drop_layer);

    virtual void seq_to_cir(
        layer_iter_seq& tmp_seq,
        QProg& prog,
        const size_t start_layer_to_cir,
        const size_t max_output_layer
        );

    virtual void seq_to_cir(layer_iter_seq& tmp_seq, QProg& prog);
    virtual void add_node_to_seq(layer_iter_seq& tmp_seq, NodeIter node_iter, const size_t layer);

Detailed Documentation

Methods

QProg replase_sub_cir(std::function<QCircuit(const size_t)> get_cir_fun)

replace sub circuit

Parameters:

std::function<QCircuit(const

size_t)> the function to get a new quantum circuit

Returns:

the new quantum prog