Utilities

Overview

// typedefs

typedef QGate (*QPanda::QGateFunc)(Qubit *);

// structs

struct QPanda::CallGateInfo;
struct QPanda::KakDescription;

// classes

class QPanda::AdjacentQGates;
class QPanda::BasicGridDevice;
class QPanda::CancelControlQubitVector;
class QPanda::ConfigMap;
class QPanda::CrossEntropyBenchmarking;
class QPanda::DecomposeControlUnitarySingleQGate;
class QPanda::DecomposeDoubleQGate;
class QPanda::DecomposeMultipleControlQGate;
class QPanda::DecomposeUnitarySingleQGateIntoMetadataSingleQGate;
class DeleteUnitQnode;
class QPanda::DoubleGateTypeValidator;
class QPanda::DRAW_TEXT_PIC::DrawQProg;
class QPanda::ExGridDevice;
class QPanda::Exp;
class QPanda::FillQProg;
class QPanda::GetAllNodeType;
class QPanda::GetAllUsedQubitAndCBit;
class QPanda::GraphDijkstra;
class QPanda::JsonConfigParam;
class QPanda::KAK;
class QPanda::MergeSingleGate;
class QPanda::MetadataValidity;
class QPanda::NodeInfo;
class QPanda::OriginIRVisitor;
class QPanda::QASMToQProg;
class QPanda::QCircuitParam;
class QPanda::QCodarMatch;
class QPanda::QGateCompare;
class QPanda::QGateCounter;
class QPanda::QPandaException;
class QPanda::QProgBuilder;
class QPanda::QProgClockCycle;
class QPanda::QProgDAG;
class QPanda::QProgDataParse;
class QPanda::QProgFlattening;
class QPanda::QProgStored;
class QPanda::QProgToMatrix;
class QPanda::QProgToOriginIR;
class QPanda::QProgToQASM;
class QPanda::QProgToQCircuit;
class QPanda::QProgToQGate;
class QPanda::QProgToQMeasure;
class QPanda::QProgToQuil;
class QPanda::QRunesToQProg;
class QPanda::QScheduler;
class QPanda::QString;
class QPanda::QuantumMetadata;
class QPanda::QuantumVolume;
class QPanda::RandomCircuit;
class QPanda::RandomizedBenchmarking;
class ReadLock;
class QPanda::RemapQProg;
class QPanda::SU4TopologyMatch;
class SharedMutex;
class QPanda::SimpleGridDevice;
class QPanda::SingleGateTypeValidator;
class QPanda::TimeSequenceConfig;
class QPanda::TopologyMatch;
class QPanda::TransformByCNOT;
class QPanda::TransformByCZ;
class QPanda::TransformByISWAP;
class QPanda::TransformBySWAP;
class QPanda::TransformDecomposition;
class QPanda::TransformQGateType;
class QPanda::TransformSwapAlg;
class QPanda::TransformSwapAlgFactory;
class QPanda::Traversal;
class QPanda::TraversalConfig;

template <typename... Args>
class QPanda::TraversalInterface;

class QPanda::TraverseByNodeIter;
class QPanda::UncompletedGridDevice;
class WriteLock;
class QPanda::init_fail;
class QPanda::qalloc_fail;
class QPanda::qcircuit_construction_fail;
class QPanda::qprog_construction_fail;
class QPanda::qprog_syntax_error;
class QPanda::qvm_attributes_error;
class QPanda::result_get_fail;
class QPanda::run_fail;
class QPanda::undefine_error;

// global functions

QProg QPanda::transformOriginIRToQProg(std::string filePath, QuantumMachine* qm, QVec& qv, std::vector<ClassicalCondition>& cv);
QProg QPanda::convert_originir_to_qprog(std::string file_path, QuantumMachine* qm);
QProg QPanda::convert_originir_to_qprog(std::string file_path, QuantumMachine* qm, QVec& qv, std::vector<ClassicalCondition>& cv);
QProg QPanda::convert_originir_string_to_qprog(std::string str_originir, QuantumMachine* qm);
QProg QPanda::convert_originir_string_to_qprog(std::string str_originir, QuantumMachine* qm, QVec& qv, std::vector<ClassicalCondition>& cv);
QProg QPanda::convert_qasm_to_qprog(std::string file_path, QuantumMachine* qvm);
QProg QPanda::convert_qasm_to_qprog(std::string file_path, QuantumMachine* qvm, QVec& qv, std::vector<ClassicalCondition>& cv);
QProg QPanda::convert_qasm_string_to_qprog(std::string qasm_str, QuantumMachine* qvm);
QProg QPanda::convert_qasm_string_to_qprog(std::string qasm_str, QuantumMachine* qvm, QVec& qv, std::vector<ClassicalCondition>& cv);

bool QPanda::transformBinaryDataToQProg(
    QuantumMachine* qm,
    const std::vector<uint8_t>& data,
    QVec& qubits,
    std::vector<ClassicalCondition>& cbits,
    QProg& prog
    );

bool QPanda::transformBinaryDataToQProg(QuantumMachine* qm, const std::string& filename, QVec& qubits, std::vector<ClassicalCondition>& cbits, QProg& prog);

bool QPanda::convert_binary_data_to_qprog(
    QuantumMachine* qm,
    const std::vector<uint8_t>& data,
    QVec& qubits,
    std::vector<ClassicalCondition>& cbits,
    QProg& prog
    );

bool QPanda::convert_binary_data_to_qprog(QuantumMachine* qm, const std::string& filename, QVec& qubits, std::vector<ClassicalCondition>& cbits, QProg& prog);
std::vector<uint8_t> QPanda::transformQProgToBinary(QProg& prog, QuantumMachine* qm);
void QPanda::transformQProgToBinary(QProg& prog, QuantumMachine* qm, const std::string& filename);
std::vector<uint8_t> QPanda::convert_qprog_to_binary(QProg& prog, QuantumMachine* qm);
void QPanda::convert_qprog_to_binary(QProg& prog, QuantumMachine* qm, const std::string& filename);

template <typename _Ty>
std::string QPanda::transformQProgToOriginIR(_Ty& node, QuantumMachine* machine);

template <typename _Ty>
std::string QPanda::convert_qprog_to_originir(_Ty& node, QuantumMachine* machine);

void QPanda::write_to_originir_file(QProg prog, QuantumMachine* qvm, const std::string file_name);
std::string QPanda::convert_qprog_to_qasm(QProg& prog, QuantumMachine* qm);
void QPanda::write_to_qasm_file(QProg prog, QuantumMachine* qvm, const std::string file_name);
std::string QPanda::transformQProgToQuil(QProg&, QuantumMachine* quantum_machine);
std::string QPanda::convert_qprog_to_quil(QProg& prog, QuantumMachine* qm);
std::vector<ClassicalCondition> QPanda::transformQRunesToQProg(std::string, QProg&, QuantumMachine*);

void QPanda::quantum_chip_adapter(
    QProg& prog,
    QuantumMachine* quantum_machine,
    QVec& new_qvec,
    bool b_mapping = true,
    const std::string config_data = CONFIG_PATH
    );

int QPanda::arbitraryRotationMetadataValidity(std::vector<std::string>& gates, std::vector<std::string>& valid_gates);
int QPanda::doubleContinuousMetadataValidity(std::vector<std::string>& gates, std::vector<std::string>& valid_gates);
int QPanda::singleContinuousAndDiscreteMetadataValidity(std::vector<std::string>& gates, std::vector<std::string>& valid_gates);
int QPanda::doubleDiscreteMetadataValidity(std::vector<std::string>& gates, std::vector<std::string>& valid_gates);
int QPanda::doubleGateMetadataValidity(std::vector<std::string>& gates, std::vector<std::string>& valid_gates);
int QPanda::validateSingleQGateType(std::vector<std::string>& gates, std::vector<std::string>& valid_gates);
bool QPanda::isMatchTopology(const QGate& gate, const std::vector<std::vector<double>>& vecTopoSt);
std::string QPanda::getAdjacentQGateType(QProg prog, NodeIter& nodeItr, std::vector<NodeInfo>& adjacentNodes);
bool QPanda::isSwappable(QProg prog, NodeIter& nodeItr1, NodeIter& nodeItr2);
bool QPanda::isSupportedGateType(const NodeIter& nodeItr);

QStat QPanda::getCircuitMatrix(
    QProg srcProg,
    const bool b_bid_endian = false,
    const NodeIter nodeItrStart = NodeIter(),
    const NodeIter nodeItrEnd = NodeIter()
    );

void QPanda::pickUpNode(
    QProg& outPutProg,
    QProg srcProg,
    const std::vector<NodeType> reject_node_types,
    const NodeIter nodeItrStart = NodeIter(),
    const NodeIter nodeItrEnd = NodeIter(),
    bool bDagger = false
    );

size_t QPanda::get_all_used_qubits(QProg prog, std::vector<int>& vecQuBitsInUse);
size_t QPanda::get_all_used_class_bits(QProg prog, std::vector<int>& vecClBitsInUse);
size_t QPanda::get_measure_info(QProg prog, std::vector<std::pair<uint32_t, uint32_t>>& measure_info);
std::string QPanda::printAllNodeType(QProg prog);
void QPanda::get_gate_parameter(std::shared_ptr<AbstractQGateNode> pGate, std::string& para_str);
bool QPanda::check_dagger(std::shared_ptr<AbstractQGateNode> p_gate, const bool& b_dagger);

template <typename _Ty>
size_t QPanda::getQGateNum(_Ty& node);

size_t QPanda::getQProgClockCycle(QProg& prog, QuantumMachine* qm, bool optimize = false);
size_t QPanda::get_qprog_clock_cycle(QProg& prog, QuantumMachine* qm, bool optimize = false);

std::string QPanda::draw_qprog(
    QProg prog,
    uint32_t length = 100,
    bool b_out_put_to_file = false,
    const NodeIter itr_start = NodeIter(),
    const NodeIter itr_end = NodeIter()
    );

std::string QPanda::draw_qprog_with_clock(
    QProg prog,
    const std::string config_data = CONFIG_PATH,
    uint32_t length = 100,
    bool b_out_put_to_file = false,
    const NodeIter itr_start = NodeIter(),
    const NodeIter itr_end = NodeIter()
    );

std::ostream& QPanda::operator << (std::ostream& out, QProg prog);
QProg QPanda::qcodar_match_by_simple_type(QProg prog, QVec& qv, QuantumMachine* machine, size_t m = 2, size_t n = 4, size_t run_times = 5);

Detailed Documentation

Typedefs

typedef QGate (*QPanda::QGateFunc)(Qubit *)

Apply Quantum Gate on a series of Qubit.

Parameters:

QVec	qubit vector
std::function<QGate(Qubit*)>	QGate function

Returns:

QCircuit

Global Functions

QProg QPanda::transformOriginIRToQProg(
    std::string filePath,
    QuantumMachine* qm,
    QVec& qv,
    std::vector<ClassicalCondition>& cv
    )

OriginIR Transform To Quantum Program.

Parameters:

std::string	OriginIR file path
QuantumMachine*	quantum machine pointer
QVec	qubit pointer
std::vector<ClassicalCondition>	classical register vector

Returns:

QProg quantum program

QProg QPanda::convert_originir_to_qprog(std::string file_path, QuantumMachine* qm)

Convert OriginIR To Quantum Program.

Parameters:

std::string	OriginIR file path
QuantumMachine*	quantum machine pointer

Returns:

QProg quantum program

QProg QPanda::convert_originir_to_qprog(
    std::string file_path,
    QuantumMachine* qm,
    QVec& qv,
    std::vector<ClassicalCondition>& cv
    )

Convert OriginIR To Quantum Program.

Parameters:

std::string	OriginIR file path
QuantumMachine*	quantum machine pointer
QVec	qubit pointer vector
std::vector<ClassicalCondition>	classical register vector

Returns:

QProg quantum program

QProg QPanda::convert_originir_string_to_qprog(std::string str_originir, QuantumMachine* qm)

Convert OriginIR String To Quantum Program.

Parameters:

std::string	OriginIR String
QuantumMachine*	quantum machine pointer

Returns:

QProg quantum program

QProg QPanda::convert_originir_string_to_qprog(
    std::string str_originir,
    QuantumMachine* qm,
    QVec& qv,
    std::vector<ClassicalCondition>& cv
    )

Convert OriginIR String To Quantum Program.

Parameters:

std::string	OriginIR String
QuantumMachine*	quantum machine pointer
QVec	qubit pointer
std::vector<ClassicalCondition>	classical register vector

Returns:

QProg quantum program

QProg QPanda::convert_qasm_to_qprog(std::string file_path, QuantumMachine* qvm)

QASM Transform To Quantum Program.

Parameters:

std::string	QASM file path
QuantumMachine*	quantum machine pointer

Returns:

QProg quantum program

QProg QPanda::convert_qasm_to_qprog(
    std::string file_path,
    QuantumMachine* qvm,
    QVec& qv,
    std::vector<ClassicalCondition>& cv
    )

QASM Transform To Quantum Program.

Parameters:

std::string	QASM file path
QuantumMachine*	quantum machine pointer
QVec	qubit pointer vector
std::vector<ClassicalCondition>	classical register vector

Returns:

QProg quantum program

QProg QPanda::convert_qasm_string_to_qprog(std::string qasm_str, QuantumMachine* qvm)

QASM Transform To Quantum Program.

Parameters:

std::string	QASM string
QuantumMachine*	quantum machine pointer

Returns:

QProg quantum program

QProg QPanda::convert_qasm_string_to_qprog(
    std::string qasm_str,
    QuantumMachine* qvm,
    QVec& qv,
    std::vector<ClassicalCondition>& cv
    )

QASM Transform To Quantum Program.

Parameters:

std::string	QASM string
QuantumMachine*	quantum machine pointer
QVec	qubit pointer vector
std::vector<ClassicalCondition>	classical register vector @retur

bool QPanda::transformBinaryDataToQProg(
    QuantumMachine* qm,
    const std::vector<uint8_t>& data,
    QVec& qubits,
    std::vector<ClassicalCondition>& cbits,
    QProg& prog
    )

Parse quantum program interface for binary data vector.

Parameters:

QuantumMachine*	quantum machine pointer
std::vector<uint8_t>&	data binary data vector
QVec&	qubits
std::vector<ClassicalCondition>&	cbits
QProg&	Quantum program

Returns:

bool

bool QPanda::transformBinaryDataToQProg(
    QuantumMachine* qm,
    const std::string& filename,
    QVec& qubits,
    std::vector<ClassicalCondition>& cbits,
    QProg& prog
    )

Parse quantum program interface for binary file.

Parameters:

QuantumMachine*	quantum machine pointer
std::string&	binary file name
QVec&	qubits
std::vector<ClassicalCondition>&	cbits
QProg&	Quantum program

Returns:

bool

bool QPanda::convert_binary_data_to_qprog(
    QuantumMachine* qm,
    const std::vector<uint8_t>& data,
    QVec& qubits,
    std::vector<ClassicalCondition>& cbits,
    QProg& prog
    )

Parse quantum program interface for binary data vector.

Parameters:

QuantumMachine*	quantum machine pointer
std::vector<uint8_t>&	data binary data vector
QVec&	qubits
std::vector<ClassicalCondition>&	cbits
QProg&	Quantum program

Returns:

bool

bool QPanda::convert_binary_data_to_qprog(
    QuantumMachine* qm,
    const std::string& filename,
    QVec& qubits,
    std::vector<ClassicalCondition>& cbits,
    QProg& prog
    )

Parse quantum program interface for binary file.

Parameters:

QuantumMachine*	quantum machine pointer
std::string&	binary file name
QVec&	qubits
std::vector<ClassicalCondition>&	cbits
QProg&	Quantum program

Returns:

bool

std::vector<uint8_t> QPanda::transformQProgToBinary(QProg& prog, QuantumMachine* qm)

Get quantum program binary data.

Parameters:

QProg&	quantum program
QuantumMachine&	quantum

Returns:

std::vector<uint8_t> quantum program binary data

void QPanda::transformQProgToBinary(QProg& prog, QuantumMachine* qm, const std::string& filename)

Store quantum program in binary file.

Parameters:

QProg&	quantum program
QuantumMachine*	quantum machine
std::string&	binary filename

Returns:

void

std::vector<uint8_t> QPanda::convert_qprog_to_binary(QProg& prog, QuantumMachine* qm)

Get quantum program binary data.

Parameters:

QProg&	quantum program
QuantumMachine&	quantum

Returns:

std::vector<uint8_t> quantum program binary data

void QPanda::convert_qprog_to_binary(QProg& prog, QuantumMachine* qm, const std::string& filename)

Store quantum program in binary file.

Parameters:

QProg&	quantum program
QuantumMachine*	quantum machine
std::string&	binary filename

Returns:

void

template <typename _Ty>
std::string QPanda::transformQProgToOriginIR(
    _Ty& node,
    QuantumMachine* machine
    )

Quantum Program Transform To OriginIR

Parameters:

_Ty&	quantum program, quantum circuit, quantum while or quantum if

Returns:

std::string OriginIR instruction set

See also:

  init(QuantumMachine_type::CPU);

  auto qubit = qAllocMany(6);
  auto cbit  = cAllocMany(2);
  auto prog = CreateEmptyQProg();

  prog << CZ(qubit[0], qubit[2]) << H(qubit[1]) << CNOT(qubit[1], qubit[2])
  << RX(qubit[0],pi/2) << Measure(qubit[1],cbit[1]);
extern QuantumMachine* global_quantum_machine;
  std::cout << transformQProgToOriginIR(prog, global_quantum_machine) << std::endl;
  finalize();

template <typename _Ty>
std::string QPanda::convert_qprog_to_originir(
    _Ty& node,
    QuantumMachine* machine
    )

Convert Quantum Program To OriginIR.

Parameters:

_Ty&	quantum program, quantum circuit, quantum while or quantum if
QuantumMachine*	quantum machine

Returns:

std::string OriginIR instruction set

void QPanda::write_to_originir_file(QProg prog, QuantumMachine* qvm, const std::string file_name)

write prog to originir file

Parameters:

QProg&	Quantum Program
QuantumMachine*	quantum machine pointer
const	std::string originir file name

Returns:

std::string QPanda::convert_qprog_to_qasm(QProg& prog, QuantumMachine* qm)

Convert Quantum program to QASM instruction set.

Parameters:

QProg&	Quantum Program
QuantumMachine*	quantum machine pointer
IBMQBackends	ibmBackend = IBMQ_QASM_SIMULATOR

Returns:

std::string QASM instruction set

void QPanda::write_to_qasm_file(QProg prog, QuantumMachine* qvm, const std::string file_name)

write prog to qasm file

Parameters:

QProg&	Quantum Program
QuantumMachine*	quantum machine pointer
const	std::string qasm file name

Returns:

std::string QPanda::transformQProgToQuil(QProg&, QuantumMachine* quantum_machine)

Quantum program transform to quil instruction set interface.

Parameters:

QProg&	quantum program
QuantumMachine*	quantum machine pointer

Returns:

std::string instruction set

See also:

  init();
  QProg prog;
  auto qvec = qAllocMany(4);
  auto cvec = cAllocMany(4);

  prog << X(qvec[0])
  << Y(qvec[1])
  << H(qvec[0])
  << RX(qvec[0], 3.14)
  << Measure(qvec[1], cvec[0])
  ;
extern QuantumMachine* global_quantum_machine;
transformQProgToQuil(prog, global_quantum_machine)
  finalize();

std::string QPanda::convert_qprog_to_quil(QProg& prog, QuantumMachine* qm)

Quantum program transform to quil instruction set interface.

Parameters:

QProg&	quantum program
QuantumMachine*	quantum machine pointer

Returns:

std::string instruction set

std::vector<ClassicalCondition> QPanda::transformQRunesToQProg(std::string, QProg&, QuantumMachine*)

QRunes instruction set transform to quantum program interface.

Parameters:

QProg&

empty quantum program

Returns:

void

void QPanda::quantum_chip_adapter(
    QProg& prog,
    QuantumMachine* quantum_machine,
    QVec& new_qvec,
    bool b_mapping = true,
    const std::string config_data = CONFIG_PATH
    )

Quantum chip adaptive conversion.

Parameters:

QProg&	Quantum Program
QuantumMachine*	quantum machine pointer
QVec&	Quantum bits after mapping. Note: if b_mapping is false, the input QVec will be misoperated.
bool	whether or not perform the mapping operation.
const	std::string It can be configuration file or configuration data, which can be distinguished by file suffix, so the configuration file must be end with “.json”, default is CONFIG_PATH

Returns:

int QPanda::arbitraryRotationMetadataValidity(
    std::vector<std::string>& gates,
    std::vector<std::string>& valid_gates
    )

Judge if the metadata’s type is arbitrary rotation.

Parameters:

std::vector<std::string>&	the gates is judged
std::vector<std::string>&	output the valid gates

Returns:

Return the style of metadata validity

int QPanda::doubleContinuousMetadataValidity(
    std::vector<std::string>& gates,
    std::vector<std::string>& valid_gates
    )

Judge if the metadata’s type is double continuous.

Parameters:

std::vector<std::string>&	the gates is judged
std::vector<std::string>&	output the valid gates

Returns:

Return the style of metadata validity

int QPanda::singleContinuousAndDiscreteMetadataValidity(
    std::vector<std::string>& gates,
    std::vector<std::string>& valid_gates
    )

Judge if the metadata’s type is single continuous and discrete.

Parameters:

std::vector<std::string>&	the gates is judged
std::vector<std::string>&	output the valid gates

Returns:

Return the style of metadata validity

int QPanda::doubleDiscreteMetadataValidity(
    std::vector<std::string>& gates,
    std::vector<std::string>& valid_gates
    )

Judge if the metadata’s type is double discrete.

Parameters:

std::vector<std::string>&	the gates is judged
std::vector<std::string>&	output the valid gates

Returns:

Return the style of metadata validity

int QPanda::doubleGateMetadataValidity(
    std::vector<std::string>& gates,
    std::vector<std::string>& valid_gates
    )

Judge double gate type.

Parameters:

std::vector<std::string>&	the gates is judged
std::vector<std::string>&	output the valid gates

Returns:

Return the style of metadata validity

int QPanda::validateSingleQGateType(
    std::vector<std::string>& gates,
    std::vector<std::string>& valid_gates
    )

Verify the validity of single quantum gates.

Parameters:

std::vector<std::string>&	gates vertor
std::vector<std::string>&	output the valid gates

Returns:

int single quantum gate type

bool QPanda::isMatchTopology(
    const QGate& gate,
    const std::vector<std::vector<double>>& vecTopoSt
    )

judge the Qgate if match the target topologic structure of quantum circuit

Parameters:

vector<vector<double>>&

the target topologic structure of quantum circuit

Returns:

if the Qgate match the target topologic structure return true, or else return false

See also:

JsonConfigParam::readAdjacentMatrix(TiXmlElement *, int&, std::vector<std::vector<int>>&)

std::string QPanda::getAdjacentQGateType(
    QProg prog,
    NodeIter& nodeItr,
    std::vector<NodeInfo>& adjacentNodes
    )

get the adjacent quantum gates’s(the front one and the back one) type

Parameters:

nodeItr	the specialed NodeIter
std::vector<NodeInfo>&	adjacentNodes the front node and the back node

Returns:

result string.

See also:

bool QPanda::isSwappable(QProg prog, NodeIter& nodeItr1, NodeIter& nodeItr2)

judge the specialed two NodeIters whether can be exchanged

If the two input nodeIters are in different sub-prog, they are unswappable.

Parameters:

nodeItr1	the first NodeIter
nodeItr2	the second NodeIter

Returns:

if the two NodeIters can be exchanged, return true, otherwise retuen false.

bool QPanda::isSupportedGateType(const NodeIter& nodeItr)

judge if the target node is a base QGate type

Parameters:

nodeItr

the target NodeIter

Returns:

if the target node is a base QGate type, return true, otherwise retuen false.

See also:

QStat QPanda::getCircuitMatrix(
    QProg srcProg,
    const bool b_bid_endian = false,
    const NodeIter nodeItrStart = NodeIter(),
    const NodeIter nodeItrEnd = NodeIter()
    )

get the target matrix between the input two Nodeiters

Parameters:

const	bool Qubit order mark of output matrix, true for positive sequence(Bid Endian), false for inverted order(Little Endian), default is false
nodeItrStart	the start NodeIter
nodeItrEnd	the end NodeIter

Returns:

the target matrix include all the QGate ‘s matrix (multiply).

See also:

void QPanda::pickUpNode(
    QProg& outPutProg,
    QProg srcProg,
    const std::vector<NodeType> reject_node_types,
    const NodeIter nodeItrStart = NodeIter(),
    const NodeIter nodeItrEnd = NodeIter(),
    bool bDagger = false
    )

pick up the nodes of srcProg between nodeItrStart and nodeItrEnd to outPutProg

Parameters:

outPutProg	the output prog
srcProg	The source prog
nodeItrStart	The start pos of source prog
nodeItrEnd	The end pos of source prog
reject_node_types	vector of the reject node types.
bDagger	daggger flag @ Note: If there are any Qif/Qwhile nodes between nodeItrStart and nodeItrEnd, Or the nodeItrStart and the nodeItrEnd are in different sub-circuit, an exception will be throw.

size_t QPanda::get_all_used_qubits(QProg prog, std::vector<int>& vecQuBitsInUse)

Get all the used quantum bits in the input prog.

Parameters:

prog	the input prog
vecQuBitsInUse	The vector of used quantum bits, sorted from small to large;

Returns:

return the size of used qubits,sorted by physical address, in descending order

size_t QPanda::get_all_used_class_bits(QProg prog, std::vector<int>& vecClBitsInUse)

Get all the used class bits in the input prog.

Parameters:

prog	the input prog
vecClBitsInUse	The vector of used class bits, sorted from small to large;

Returns:

return the size of used class bits

size_t QPanda::get_measure_info(
    QProg prog,
    std::vector<std::pair<uint32_t, uint32_t>>& measure_info
    )

Get all the measure-info in the input prog.

Parameters:

prog	the input prog
std::vector<std::pair<uint32_t
uint32_t>>	The vector of measure-info: std::pair<measured-qubit, target-cbit>

Returns:

return the size of measure-info

std::string QPanda::printAllNodeType(QProg prog)

output all the node type of the target prog

Parameters:

the	target prog

Returns:

return the output string

void QPanda::get_gate_parameter(std::shared_ptr<AbstractQGateNode> pGate, std::string& para_str)

get gate parameter

Parameters:

pGate	the target gate pointer
para_str	parameter string

Returns:

bool QPanda::check_dagger(std::shared_ptr<AbstractQGateNode> p_gate, const bool& b_dagger)

Check if it is a valid dagger.

Parameters:

bool

Returns:

bool true for valid dagger

template <typename _Ty>
size_t QPanda::getQGateNum(_Ty& node)

Count quantum gate num under quantum program, quantum circuit, quantum while, quantum if.

Parameters:

_Ty&	quantum program, quantum circuit, quantum while or quantum if

Returns:

size_t Quantum gate num

See also:

init();
auto qubits = qAllocMany(4);
auto cbits = cAllocMany(4);

auto circuit = CreateEmptyCircuit();
circuit << H(qubits[0]) << X(qubits[1]) << S(qubits[2])
<< iSWAP(qubits[1], qubits[2]) << RX(qubits[3], PI/4);
auto count = getQGateNumber(&circuit);
std::cout << "QCircuit count: " << count << std::endl;

finalize();

size_t QPanda::getQProgClockCycle(QProg& prog, QuantumMachine* qm, bool optimize = false)

Get quantum program clock cycle.

Parameters:

QProg	& quantum program
QuantumMachine*	quantum machine pointer

See also:

init();
auto qubits = qAllocMany(4);
auto prog = CreateEmptyQProg();
prog << H(qubits[0]) << CNOT(qubits[0], qubits[1])
        << iSWAP(qubits[1], qubits[2]) << RX(qubits[3], PI/4);
extern QuantumMachine* global_quantum_machine;
auto time = getQProgClockCycle(prog,global_quantum_machine );
std::cout << "clockCycle : " << time << std::endl;

finalize();

size_t QPanda::get_qprog_clock_cycle(QProg& prog, QuantumMachine* qm, bool optimize = false)

Get quantum program clock cycle.

Parameters:

QProg	& quantum program
QuantumMachine*	quantum machine pointer

std::string QPanda::draw_qprog(
    QProg prog,
    uint32_t length = 100,
    bool b_out_put_to_file = false,
    const NodeIter itr_start = NodeIter(),
    const NodeIter itr_end = NodeIter()
    )

output a quantum prog/circuit to console by text-pic(UTF-8 code), and will save the text-pic in file named QCircuitTextPic.txt in the same time in current path.

All the output characters are UTF-8 encoded.

Parameters:

prog	the source prog
itr_start	The start pos, default is the first node of the prog
itr_end	The end pos, default is the end node of the prog

Returns:

the output string

std::string QPanda::draw_qprog_with_clock(
    QProg prog,
    const std::string config_data = CONFIG_PATH,
    uint32_t length = 100,
    bool b_out_put_to_file = false,
    const NodeIter itr_start = NodeIter(),
    const NodeIter itr_end = NodeIter()
    )

output a quantum prog/circuit by time sequence to console by text-pic(UTF-8 code), and will save the text-pic in file named QCircuitTextPic.txt in the same time in current path.

All the output characters are GBK encoded on windows, UTF-8 encoded on other OS.

Parameters:

prog	the source prog
const	std::string It can be configuration file or configuration data, which can be distinguished by file suffix, so the configuration file must be end with “.json”, default is CONFIG_PATH
itr_start	The start pos, default is the first node of the prog
itr_end	The end pos, default is the end node of the prog

Returns:

the output string

std::ostream& QPanda::operator << (std::ostream& out, QProg prog)

Overload operator <<.

Parameters:

std::ostream&	ostream
QProg	quantum program

Returns:

std::ostream

QProg QPanda::qcodar_match_by_simple_type(
    QProg prog,
    QVec& qv,
    QuantumMachine* machine,
    size_t m = 2,
    size_t n = 4,
    size_t run_times = 5
    )

A Contextual Duration-Aware Qubit Mapping for V arious NISQ Devices.

QCodarGridDevice : SIMPLE_TYPE It’s a simple undirected topology graph, build a topology based on the values of m and n 0 = 1 = 2 = 3

eg: m = 2, n = 4

Parameters:

QProg	quantum program
QVec	qubit vector
QuantumMachine*	quantum machine
size_t	m : the length of the topology
size_t	n : the width of the topology
size_t	run_times : the number of times run the remapping, better parameters get better results

Returns:

QProg mapped quantum program