namespace QPanda

Overview

namespace QPanda {

// namespaces

namespace QPanda::DRAW_TEXT_PIC;
namespace QPanda::Variational;

// typedefs

typedef std::pair<size_t, bool> OrbitalAct;
typedef std::vector<OrbitalAct> OrbitalActVec;
typedef std::pair<OrbitalActVec, std::string> FermionPair;
typedef FermionOp<complex_d> FermionOperator;
typedef PauliOp<complex_d> PauliOperator;
typedef AbstractClassicalProg* (*CreateClassicalQProgram)(ClassicalCondition &);

typedef AbstractControlFlowNode* (*CreateQIfTrueFalse_cb)(
    ClassicalCondition &,
    QProg,
    QProg
    );

typedef AbstractControlFlowNode* (*CreateQIfTrueOnly_cb)(
    ClassicalCondition &,
    QProg
    );

typedef AbstractControlFlowNode* (*CreateQWhile_cb)(
    ClassicalCondition &,
    QProg
    );

typedef AbstractQuantumCircuit* (*CreateQCircuit)();

typedef void (*QGATE_FUN)(
    QuantumGate *,
    QVec &,
    QPUImpl *,
    bool,
    QVec &,
    GateType
    );

typedef std::map<int, QGATE_FUN> QGATE_FUN_MAP;
typedef int64_t qmap_size_t;
typedef AbstractQuantumProgram* (*CreateQProgram)();
typedef AbstractQuantumReset* (*CreateReset)(Qubit *);

typedef AbstractQuantumMeasure* (*CreateMeasure)(
    Qubit *,
    CBit *
    );

typedef long long cbit_size_t;
typedef std::pair<std::string, std::string> CONFIGPAIR;
typedef std::function<int(std::vector<std::string>&, std::vector<std::string>&)> MetadataValidity_cb;
typedef std::vector<uint32_t> Vector;
typedef std::vector<Vector> Matrix;
typedef std::vector<Mapping> MappingVector;
typedef std::vector<std::vector<Mapping>> MappingVectorCollection;
typedef std::vector<SwapSeq> SwapSeqVector;
typedef std::vector<QNodeRef> PPartition;
typedef std::vector<PPartition> PPartitionCollection;
typedef std::vector<uint32_t> Mapping;
typedef std::vector<uint32_t> InverseMap;
typedef std::vector<Swap> SwapSeq;
typedef std::map<std::string, uint32_t> GateWeightMap;
typedef Eigen::MatrixXi AdjacencyMatrix;
typedef SeqNode<DAGSeqNode> DAGTopoNode;
typedef SeqLayer<DAGSeqNode> DAGTopoLayer;
typedef std::pair<T, std::vector<T>> SeqNode;
typedef std::vector<SeqNode<T>> SeqLayer;
typedef std::vector<std::vector<T>> MatData;
typedef MatData<int> TopologyData;
typedef std::pair<size_t, size_t> QubitPair;
typedef std::pair<size_t, std::vector<int>> weight_edge;
typedef rapidjson::Value Value;
typedef std::shared_ptr<OptimizerNodeInfo> pOptimizerNodeInfo;
typedef std::map<size_t, size_t> SinkPos;
typedef std::pair<size_t, std::vector<pOptimizerNodeInfo>> GatesBufferType;
typedef QubitNodesSink OptimizerSink;
typedef TopologSequence<pOptimizerNodeInfo> LayeredTopoSeq;
typedef std::shared_ptr<PressedCirNode> pPressedCirNode;
typedef TopologSequence<pPressedCirNode> PressedTopoSeq;
typedef SeqLayer<pPressedCirNode> PressedLayer;
typedef SeqNode<pPressedCirNode> PressedNode;
typedef double EigneDataType;
typedef std::complex<EigneDataType> EigenComplexT;
typedef Eigen::Matrix<EigenComplexT, -1, -1, Eigen::RowMajor> EigenMatrixXc;
typedef Eigen::Matrix<EigenComplexT, 2, 2> EigenMatrix2c;
typedef Eigen::Matrix<EigneDataType, -1, -1> EigenMatrixX;
typedef Eigen::Matrix<EigneDataType, 2, 2> EigenMatrix2;
typedef Eigen::Matrix<qcomplex_t, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> qmatrix_t;
typedef struct QPanda::_matrix_block matrixBlock_t;
typedef struct QPanda::_blocked_matrix blockedMatrix_t;
typedef std::function<void(void)> Task;
typedef QGate (*QGateFunc)(Qubit *);
typedef std::function<QCircuit(InputType, OutputType)> Oracle;
typedef FermionOp<complex_var> VarFermionOperator;
typedef PauliOp<complex_var> VarPauliOperator;
typedef std::pair<size_t, size_t> DoubleQubits;
typedef std::vector<QGateNode> cir_type;
typedef Oracle<QVec, Qubit*> BV_Oracle;
typedef Oracle<QVec, Qubit*> DJ_Oracle;
typedef Oracle<QVec, Qubit*> grover_oracle;

// enums

enum ArchType;
enum CLOUD_QMACHINE_TYPE;
enum ComplexVertexSplitMethod;
enum ContentSpecifier;
enum DAGNodeType;
enum DecompositionMode;
enum DoubleGateTransferType;
enum KarusErrorType;
enum MatrixUnit;
enum MeasBasis;
enum MeasState;
enum MeasureQVMType;
enum OperatorSpecifier;
enum PrepState;
enum QASMGateType;
enum QCircuitOPtimizerMode;
enum QCodarGridDevice;
enum QMachineType;
enum QProgStoredNodeType;
enum REAL_CHIP_TYPE;
enum SingleGateTransferType;
enum SwapQubitsMethod;

// structs

template <typename T>
struct CNodeCandidate;

struct CallGateInfo;
struct CandidateSelector;
struct DAGSeqNode;
struct DefineQGateContent;
struct Dep;
struct Dependencies;
struct Dist;
struct FragLabel;
struct GataFuncInfo;
struct GateInfo;
struct GateOperationInfo;

template <>
struct JsonBackendParser<ArchGraph>;

template <class T>
struct JsonBackendParser;

template <class T>
struct JsonBackendParser<WeightedGraph<T>>;

template <>
struct JsonBackendParser<Graph>;

template <>
struct JsonFields<ArchGraph>;

template <class T>
struct JsonFields<WeightedGraph<T>>;

template <>
struct JsonFields<Graph>;

template <class T>
struct JsonFields;

struct KakDescription;
struct MappingCandidate;
struct MappingSeq;
struct MappingSwapSequence;
struct NoiseConfigs;
struct OptimizerNodeInfo;
struct OptimizerSubCir;
struct PressedCirNode;
struct QCircuitConfig;
struct QCircuitConfigReader;
struct QGateNode;
struct QGatesTransform;
struct QProgDAGEdge;
struct QProgDAGNode;
struct QubitPointerCmp;
struct RegParamInfo;
struct StitchesInfo;
struct SubCircuit;
struct Swap;
struct TracebackInfo;
struct _blocked_matrix;
struct _matrix_block;
struct axis;

// classes

class AbstractCirOptimizer;
class AbstractClassicalProg;
class AbstractControlFlowNode;
class AbstractDiffusionOperator;
class AbstractNodeManager;
class AbstractOptimizer;
class AbstractQGateNode;
class AbstractQuantumCircuit;
class AbstractQuantumCounting;
class AbstractQuantumMeasure;
class AbstractQuantumProgram;
class AbstractQuantumReset;
class AbstractQubitMapping;
class AbstractSearchData;
class AdjacentQGates;
class ApproxTSFinder;
class ArchGraph;
class BasicGridDevice;
class Brent;
class CBit;
class CBitFactory;
class CBitFactoryHelper;
class CExpr;
class CExprFactory;
class CExprFactoryHelper;
class CMem;
class CMemFactory;
class CMemFactoryHelper;
class CPUQVM;
class CPUSingleThreadQVM;
class CancelControlQubitVector;
class ChemiQ;
class ClassicalCondition;
class ClassicalProg;
class ClassicalProgFactory;
class ClassicalProgRegisterAction;
class ConfigMap;
class Configuration;
class CrossEntropyBenchmarking;
class CutQCircuit;
class DecomposeControlSingleQGateIntoMetadataDoubleQGate;
class DecomposeControlUnitarySingleQGate;
class DecomposeDoubleQGate;
class DecomposeMultipleControlQGate;
class DecomposeUnitarySingleQGateIntoMetadataSingleQGate;
class DeleteUnitQNode;
class DiffusionCirBuilder;
class DoubleGateTypeValidator;
class DynamicQCircuitGraph;
class ExGridDevice;
class Exp;

template <class T>
class FermionOp;

class FillQProg;
class FindSubCircuit;
class FragmentResult;
class FrontLayer;
class GPUQVM;
class GetAllNodeType;
class GetAllUsedQubitAndCBit;
class GetQubitTopology;
class Graph;
class GraphDijkstra;
class HHLAlg;
class HadamardQCircuit;
class IdealMachineInterface;
class IdealQVM;
class Item;
class JsonConfigParam;

template <class T>
class JsonParser;

class JudgeTwoNodeIterIsSwappable;
class KAK;
class KarusError;
class MPSImplQPU;
class MPSQVM;
class MergeSingleGate;
class MetadataValidity;
class MultiPrecisionMachineInterface;
class NodeInfo;
class NodeIter;
class NodeSortProblemGenerator;
class NoiseQVM;
class NoiseSimulator;
class NonKarusError;
class OptBMTQAllocator;
class OptimizerFactory;

template <class T>
class OracleBuilder;

class OriginCBit;
class OriginCExpr;
class OriginCMem;
class OriginCMemv2;
class OriginCOBYLA;
class OriginCircuit;
class OriginClassicalProg;
class OriginCollection;
class OriginIRVisitor;
class OriginItem;
class OriginLBFGSB;
class OriginMeasure;
class OriginNelderMead;
class OriginPhysicalQubit;
class OriginPowell;
class OriginProgram;
class OriginQGate;
class OriginQIf;
class OriginQMachineStatus;
class OriginQResult;
class OriginQWhile;
class OriginQubit;
class OriginQubitPool;
class OriginQubitPoolv1;
class OriginQubitPoolv2;
class OriginReset;
class OriginSLSQP;
class ParseExpressionStr;
class PartialAmplitudeGraph;
class PartialAmplitudeQVM;

template <class T>
class PauliOp;

class PhysicalQubit;
class PhysicalQubitFactory;
class PhysicalQubitFactoryHelper;
class PickUpNodes;
class ProcessOnTraversing;
class Psi4Wrapper;
class QAOA;
class QARM;
class QASMToQProg;
class QCirFragments;
class QCircuit;
class QCircuitGenerator;
class QCircuitOPtimizer;
class QCircuitOptimizerConfig;
class QCircuitParam;
class QCircuitRewrite;
class QCloudMachine;
class QCodarMatch;
class QGate;
class QGateCompare;
class QGateCounter;
class QGateNodeFactory;
class QGateParseMap;
class QITE;
class QIfFactory;
class QIfProg;
class QIfRegisterAction;
class QMachineStatus;
class QMachineStatusFactory;
class QMachineTypeTarnfrom;
class QMeasure;
class QNode;
class QNodeDeepCopy;
class QNodeManager;
class QObject;
class QPEAlg;
class QPandaException;
class QProg;
class QProgBuilder;
class QProgCheck;
class QProgClockCycle;
class QProgDAG;
class QProgDAGVertex;
class QProgDataParse;
class QProgExecution;
class QProgFlattening;
class QProgStored;
class QProgToDAG;
class QProgToMatrix;
class QProgToOriginIR;
class QProgToQASM;
class QProgToQCircuit;
class QProgToQGate;
class QProgToQMeasure;
class QProgToQuil;
class QReset;
class QResetFactory;
class QResult;
class QResultFactory;
class QResultFactoryHelper;
class QRunesToQProg;
class QSVM;
class QScheduler;
class QString;
class QVM;
class QVec;
class QWhileFactory;
class QWhileProg;
class QWhileRegisterAction;
class QuantumChipAdapter;
class QuantumChipConfig;
class QuantumCircuitFactory;
class QuantumCircuitRegisterAction;
class QuantumCounting;
class QuantumMachine;
class QuantumMachineFactory;
class QuantumMachineFactoryHelper;
class QuantumMeasureFactory;
class QuantumMeasureRegisterAction;
class QuantumMetadata;
class QuantumProgramFactory;
class QuantumProgramRegisterAction;
class QuantumResetRegisterAction;
class QuantumVolume;
class Qubit;
class QubitAddr;
class QubitFactory;
class QubitFactoryHelper;
class QubitNodesSink;
class QubitPool;
class QubitPoolFactory;
class QubitPoolFactoryHelper;
class QubitReference;
class QubitReferenceInterface;
class RBGate;
class RJson;
class RandomCircuit;
class RandomizedBenchmarking;
class RecombineFragment;
class RemapQProg;
class ResultData;
class SU4TopologyMatch;
class SabreQAllocator;

template <class T>
class SearchCondition;

class SearchDataByUInt;

template <class T>
class SearchSpace;

class ShorAlg;
class ShortestDistanceByBFS;
class SimpleGridDevice;
class SimplifiedApproxTSFinder;
class SingleAmplitudeQVM;
class SingleGateTypeValidator;
class TimeSequenceConfig;
class TokenSwapFinder;

template <class T>
class TopologSequence;

class TopologyMatch;
class TransformByCNOT;
class TransformByCZ;
class TransformByISWAP;
class TransformBySWAP;
class TransformDecomposition;
class TransformQGateType;
class TransformSwapAlg;
class TransformSwapAlgFactory;
class Traversal;
class TraversalConfig;

template <typename... Args>
class TraversalInterface;

class TraverseByNodeIter;
class UncompletedGridDevice;

template <typename T>
class WeightedGraph;

class calloc_fail;
class complex_var;
class gate_alloc_fail;
class init_fail;
class qalloc_fail;
class qcircuit_construction_fail;
class qprog_construction_fail;
class qprog_syntax_error;
class qvm_attributes_error;
class result_get_fail;
class run_fail;
class threadPool;
class undefine_error;

// global variables

static std::map<std::string, std::function<double(double, double)>> _binary_operation = {     {"+", [](double  lval,double rval) {return lval + rval; }},     {"-", [](double lval,double rval) {return lval - rval; } },     {"*", [](double lval,double rval) {return lval* rval; } },  {"/", [](double lval,double  rval) {return lval / rval; } }, };
const unsigned short kUshortMax = 65535;
const int kCountMoveBit = 16;
const uint32_t UNDEF_UINT32;
const int kInfinite = 0xffff;
const int kError = -1;

// global functions

DLLEXPORT size_t getElectronNum(const std::string& atom);
DLLEXPORT PauliOperator JordanWignerTransform(const OrbitalActVec& fermion_item);
DLLEXPORT PauliOperator JordanWignerTransform(const FermionOperator& fermion);
DLLEXPORT VarPauliOperator JordanWignerTransform(const VarFermionOperator& fermion);
DLLEXPORT PauliOperator ParityTransform(const OrbitalActVec& fermion_item, size_t maxqubit);
DLLEXPORT PauliOperator ParityTransform(const FermionOperator& fermio);
DLLEXPORT VarPauliOperator ParityTransform(const VarFermionOperator& fermion);
DLLEXPORT std::vector<Eigen::MatrixXi> BKMatrix(size_t qn);

DLLEXPORT PauliOperator BravyiKitaevTransform(
    const OrbitalActVec& fermion_item,
    size_t maxqubit,
    std::vector<Eigen::MatrixXi> BK
    );

DLLEXPORT PauliOperator BravyiKitaevTransform(const FermionOperator& fermion, std::vector<Eigen::MatrixXi> BK);
DLLEXPORT VarPauliOperator BravyiKitaevTransform(const VarFermionOperator& fermion, std::vector<Eigen::MatrixXi> BK);
DLLEXPORT size_t getCCS_N_Trem(size_t qn, size_t en);
DLLEXPORT size_t getCCSD_N_Trem(size_t qn, size_t en);
DLLEXPORT FermionOperator getCCS(size_t qn, size_t en, const vector_d& para_vec);
DLLEXPORT VarFermionOperator getCCS(size_t qn, size_t en, var& para);
DLLEXPORT VarFermionOperator getCCS(size_t qn, size_t en, std::vector<var>& para);
DLLEXPORT FermionOperator getCCSD(size_t qn, size_t en, const vector_d& para_vec);
DLLEXPORT VarFermionOperator getCCSD(size_t qn, size_t en, var& para);
DLLEXPORT VarFermionOperator getCCSD(size_t qn, size_t en, std::vector<var>& para);
DLLEXPORT PauliOperator transCC2UCC(const PauliOperator& cc);
DLLEXPORT VarPauliOperator transCC2UCC(const VarPauliOperator& cc);
DLLEXPORT VQC simulateHamiltonian(QVec& qubit_vec, VarPauliOperator& pauli, double t, size_t slices);
DLLEXPORT VQC simulateOneTerm(QVec& qubit_vec, const QTerm& hamiltonian_term, const var& coef, double t);
DLLEXPORT VQC simulateZTerm(QVec& qubit_vec, const var& coef, double t);
DLLEXPORT FermionOperator parsePsi4DataToFermion(const std::string& data);
QCircuit simulateZTerm(const std::vector<Qubit*>& qubit_vec, double coef, double t);

QCircuit simulateOneTerm(
    const std::vector<Qubit*>& qubit_vec,
    const QTerm& hamiltonian_term,
    double coef,
    double t
    );

QCircuit simulateHamiltonian(
    const std::vector<Qubit*>& qubit_vec,
    const QHamiltonian& hamiltonian,
    double t,
    size_t slices
    );

QCircuit simulatePauliZHamiltonian(const std::vector<Qubit*>& qubit_vec, const QHamiltonian& hamiltonian, double t);
QCircuit applySingleGateToAll(const std::string& gate, const std::vector<Qubit*>& qubit_vec);
void applySingleGateToAll(const std::string& gate, const std::vector<Qubit*>& qubit_vec, QCircuit& circuit);
QCircuit ising_model(const std::vector<Qubit*>& qubit_vec, const QGraph& graph, const vector_d& gamma);
QCircuit pauliX_model(const std::vector<Qubit*>& qubit_vec, const vector_d& beta);
double vector_dot(std::vector<double>& x, std::vector<double>& y);

double all_cut_of_graph(
    std::vector<std::vector<double>> adjacent_matrix,
    std::vector<double>& all_cut_list,
    std::vector<size_t>& target_value_list
    );

template <class T>
PauliOperator transVecToPauliOperator(const std::vector<T>& data_vec);

std::vector<double> transPauliOperatorToVec(PauliOperator pauli);
bool init(QMachineType type = CPU);
void finalize();
Qubit* qAlloc();
Qubit* qAlloc(size_t stQubitAddr);
std::map<std::string, bool> directlyRun(QProg& qProg);
QVec qAllocMany(size_t stQubitNumber);
ClassicalCondition cAlloc();
ClassicalCondition cAlloc(size_t stCBitaddr);
std::vector<ClassicalCondition> cAllocMany(size_t stCBitNumber);
void cFree(ClassicalCondition&);
void cFreeAll(std::vector<ClassicalCondition> vCBit);
QMachineStatus* getstat();
size_t getAllocateQubitNum();
prob_tuple getProbTupleList(QVec, int selectMax = -1);
prob_vec getProbList(QVec, int selectMax = -1);
prob_dict getProbDict(QVec, int selectMax = -1);
prob_tuple probRunTupleList(QProg&, QVec, int selectMax = -1);
prob_vec probRunList(QProg&, QVec, int selectMax = -1);
prob_dict probRunDict(QProg&, QVec, int selectMax = -1);
std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
std::map<std::string, size_t> quickMeasure(QVec, int);
prob_vec accumulateProbability(prob_vec& prob_list);

std::map<std::string, size_t> quick_measure(
    QVec qubit_vector,
    int shots,
    prob_vec& accumulate_probabilites
    );

QStat getQState();
QuantumMachine* initQuantumMachine(QMachineType type = CPU);
void destroyQuantumMachine(QuantumMachine* qvm);
QPanda::QProg MeasureAll(QVec, std::vector<ClassicalCondition>);
QProg transformOriginIRToQProg(std::string filePath, QuantumMachine* qm, QVec& qv, std::vector<ClassicalCondition>& cv);
QProg convert_originir_to_qprog(std::string file_path, QuantumMachine* qm);
QProg convert_originir_to_qprog(std::string file_path, QuantumMachine* qm, QVec& qv, std::vector<ClassicalCondition>& cv);
QProg convert_originir_string_to_qprog(std::string str_originir, QuantumMachine* qm);
QProg convert_originir_string_to_qprog(std::string str_originir, QuantumMachine* qm, QVec& qv, std::vector<ClassicalCondition>& cv);
QProg convert_qasm_to_qprog(std::string file_path, QuantumMachine* qvm);
QProg convert_qasm_to_qprog(std::string file_path, QuantumMachine* qvm, QVec& qv, std::vector<ClassicalCondition>& cv);
QProg convert_qasm_string_to_qprog(std::string qasm_str, QuantumMachine* qvm);
QProg convert_qasm_string_to_qprog(std::string qasm_str, QuantumMachine* qvm, QVec& qv, std::vector<ClassicalCondition>& cv);
size_t getAllocateCMem();

prob_tuple PMeasure(
    QVec qubit_vector,
    int select_max
    );

prob_vec PMeasure_no_index(QVec qubit_vector);
size_t getAllocateCMemNum();
prob_tuple pMeasure(QVec qubit_vector, int select_max);
prob_vec pMeasureNoIndex(QVec qubit_vector);
ClassicalCondition operator + (cbit_size_t value, ClassicalCondition class_cond);
ClassicalCondition operator + (ClassicalCondition left_operand, ClassicalCondition right_operand);
ClassicalCondition operator + (ClassicalCondition left_operand, cbit_size_t right_operand);
ClassicalCondition operator - (ClassicalCondition left_operand, ClassicalCondition right_operand);
ClassicalCondition operator - (ClassicalCondition left_operand, cbit_size_t right_operand);
ClassicalCondition operator - (cbit_size_t value, ClassicalCondition class_cond);
ClassicalCondition operator * (ClassicalCondition, ClassicalCondition);
ClassicalCondition operator * (ClassicalCondition, cbit_size_t);
ClassicalCondition operator * (cbit_size_t value, ClassicalCondition class_cond);
ClassicalCondition operator/ (ClassicalCondition, ClassicalCondition);
ClassicalCondition operator/ (ClassicalCondition, cbit_size_t);
ClassicalCondition operator/ (cbit_size_t value, ClassicalCondition class_cond);
ClassicalCondition operator == (ClassicalCondition, ClassicalCondition);
ClassicalCondition operator == (ClassicalCondition, cbit_size_t);
ClassicalCondition operator == (cbit_size_t value, ClassicalCondition class_cond);
ClassicalCondition operator != (ClassicalCondition, ClassicalCondition);
ClassicalCondition operator != (ClassicalCondition, cbit_size_t);
ClassicalCondition operator != (cbit_size_t value, ClassicalCondition classical_cond);
ClassicalCondition operator && (ClassicalCondition, ClassicalCondition);
ClassicalCondition operator && (ClassicalCondition, cbit_size_t);
ClassicalCondition operator && (cbit_size_t value, ClassicalCondition classical_cond);
ClassicalCondition operator|| (ClassicalCondition, ClassicalCondition);
ClassicalCondition operator|| (ClassicalCondition, cbit_size_t);
ClassicalCondition operator|| (cbit_size_t value, ClassicalCondition classical_cond);
ClassicalCondition operator > (ClassicalCondition, ClassicalCondition);
ClassicalCondition operator > (ClassicalCondition, cbit_size_t);
ClassicalCondition operator > (cbit_size_t value, ClassicalCondition class_cond);
ClassicalCondition operator >= (ClassicalCondition, ClassicalCondition);
ClassicalCondition operator >= (ClassicalCondition, cbit_size_t);
ClassicalCondition operator >= (cbit_size_t value, ClassicalCondition class_cond);
ClassicalCondition operator < (ClassicalCondition, ClassicalCondition);
ClassicalCondition operator < (ClassicalCondition, cbit_size_t);
ClassicalCondition operator < (cbit_size_t value, ClassicalCondition class_cond);
ClassicalCondition operator <= (ClassicalCondition, ClassicalCondition);
ClassicalCondition operator <= (ClassicalCondition, cbit_size_t);
ClassicalCondition operator <= (cbit_size_t value, ClassicalCondition class_cond);
ClassicalCondition operator ! (ClassicalCondition);

QIfProg CreateIfProg(
    ClassicalCondition classical_condition,
    QProg true_node
    );

QIfProg CreateIfProg(
    ClassicalCondition classical_condition,
    QProg true_node,
    QProg false_node
    );

QWhileProg CreateWhileProg(
    ClassicalCondition,
    QProg trueNode
    );

QIfProg createIfProg(ClassicalCondition cc, QProg true_node);
QIfProg createIfProg(ClassicalCondition cc, QProg true_node, QProg false_node);
QWhileProg createWhileProg(ClassicalCondition cc, QProg true_node);
QCircuit CreateEmptyCircuit();
HadamardQCircuit CreateHadamardQCircuit(QVec& pQubitVector);
QCircuit createEmptyCircuit();
HadamardQCircuit createHadamardQCircuit(QVec& pQubitVector);
QGate I(Qubit* qubit);
QGate X(Qubit* qubit);
QGate X1(Qubit* qubit);
QGate RX(Qubit*, double angle);
QGate U1(Qubit*, double angle);
QGate U2(Qubit* qubit, double phi, double lambda);
QGate U3(Qubit* qubit, double theta, double phi, double lambda);
QGate Y(Qubit* qubit);
QGate Y1(Qubit* qubit);
QGate RY(Qubit*, double angle);
QGate Z(Qubit* qubit);
QGate Z1(Qubit* qubit);
QGate RZ(Qubit*, double angle);
QGate RPhi(Qubit* qubit, double angle, double phi);
QGate S(Qubit* qubit);
QGate T(Qubit*);
QGate H(Qubit* qubit);
QGate ECHO(Qubit* qubit);
QGate BARRIER(Qubit* qubit);
QGate BARRIER(QVec qubits);
QGate CNOT(Qubit* control_qubit, Qubit* target_qubit);
QGate CZ(Qubit* control_qubit, Qubit* target_qubit);
QGate U4(double alpha, double beta, double gamma, double delta, Qubit*);
QGate U4(QStat& matrix, Qubit*);
QGate QDouble(QStat& matrix, Qubit* qubit1, Qubit* qubit2);
QGate CU(double alpha, double beta, double gamma, double delta, Qubit*, Qubit*);
QGate CU(QStat& matrix, Qubit*, Qubit*);
QGate iSWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second);
QGate iSWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second, double theta);
QGate CR(Qubit* control_qubit, Qubit* targit_qubit, double theta);
QGate SqiSWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second);
QGate SWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second);

QGate oracle(
    QVec qubits,
    std::string oracle_name
    );

QGate copy_qgate(
    QuantumGate* qgate_old,
    QVec qubit_vector
    );

QGate copy_qgate(
    QGate& qgate,
    QVec qubit_vector
    );

QGate copy_qgate(
    QGate* qgate,
    QVec qubit_vector
    );

QGate U4(Qubit*, double alpha, double beta, double gamma, double delta);
QGate U4(Qubit*, QStat& matrix);
QGate QDouble(Qubit* qubit1, Qubit* qubit2, QStat& matrix);
QGate CU(Qubit*, Qubit*, double alpha, double beta, double gamma, double delta);
QGate CU(Qubit*, Qubit*, QStat& matrix);
QGate I(int qaddr);
QGate X(int qaddr);
QGate X1(int qaddr);
QGate RX(int qaddr, double angle);
QGate U1(int qaddr, double angle);
QGate U2(int qaddr, double phi, double lambda);
QGate U3(int qaddr, double theta, double phi, double lambda);
QGate Y(int qaddr);
QGate Y1(int qaddr);
QGate RY(int qaddr, double angle);
QGate Z(int qaddr);
QGate Z1(int qaddr);
QGate RZ(int qaddr, double angle);
QGate RPhi(int qaddr, double angle, double phi);
QGate S(int qaddr);
QGate T(int qaddr);
QGate H(int qaddr);
QGate ECHO(int qaddr);
QGate BARRIER(int qaddr);
QGate BARRIER(std::vector<int> qaddrs);
QGate CNOT(int control_qaddr, int target_qaddr);
QGate CZ(int control_qaddr, int target_qaddr);
QGate iSWAP(int control_qaddr, int target_qaddr);
QGate iSWAP(int control_qaddr, int target_qaddr, double theta);
QGate CR(int control_qaddr, int target_qaddr, double theta);
QGate SqiSWAP(int control_qaddr, int target_qaddr);
QGate SWAP(int control_qaddr, int target_qaddr);
QGate U4(int qaddr, double alpha, double beta, double gamma, double delta);
QGate U4(int qaddr, QStat& matrix);
QGate QDouble(int control_qaddr, int target_qaddr, QStat& matrix);

QGate CU(
    int control_qaddr,
    int target_qaddr,
    double alpha,
    double beta,
    double gamma,
    double delta
    );

QGate CU(int control_qaddr, int target_qaddr, QStat& matrix);

template <typename _Ty>
_Ty deepCopy(_Ty& node);

QProg CreateEmptyQProg();
QProg createEmptyQProg();
QReset Reset(Qubit*);
QReset Reset(int qaddr);
QMeasure Measure(Qubit*, ClassicalCondition);
QMeasure Measure(int, int);
Qubit* get_qubit_by_phyaddr(int qaddr);
QVec get_qubits_by_phyaddrs(const std::vector<int>& qaddrs);
void execute_qprog(QProg prog, QPUImpl* qpu, TraversalConfig& param);

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

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

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

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

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

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

void storeQProgInBinary(
    QProg& prog,
    QuantumMachine* qm,
    const std::string& filename
    );

void transformQProgToBinary(QProg& prog, QuantumMachine* qm, const std::string& filename);
std::vector<uint8_t> convert_qprog_to_binary(QProg& prog, QuantumMachine* qm);
void convert_qprog_to_binary(QProg& prog, QuantumMachine* qm, const std::string& filename);

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

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

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

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

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

std::map<int, double> double_gate_xeb(
    NoiseQVM* qvm,
    Qubit* qbit0,
    Qubit* qbit1,
    const std::vector<int>& range,
    int num_circuits,
    int shots,
    GateType gt = GateType::CZ_GATE
    );

std::map<int, double> double_gate_xeb(
    QCloudMachine* qvm,
    Qubit* qbit0,
    Qubit* qbit1,
    const std::vector<int>& range,
    int num_circuits,
    int shots,
    GateType gt = GateType::CZ_GATE
    );

bool judge_prog_operate_target_qubts(QProg prog, const QCircuitParam& cir_param, const std::vector<int>& qubits_vec);

QCircuit random_kak_qcircuit(
    Qubit* in_qubit1,
    Qubit* in_qubit2
    );

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

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

void 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 get_all_used_qubits(QProg prog, std::vector<int>& vecQuBitsInUse);

size_t get_all_used_qubits(
    QProg prog,
    QVec& vecQuBitsInUse
    );

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

template <typename _Ty>
size_t getUnSupportQGateNumber(
    _Ty node,
    const std::vector<std::vector<std::string>>& gates
    );

template <typename _Ty>
size_t getUnsupportQGateNum(
    _Ty node,
    const std::vector<std::vector<std::string>>& gates
    );

template <typename _Ty>
size_t getQGateNumber(_Ty& node);

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

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

size_t calculate_quantum_volume(
    NoiseQVM* qvm,
    std::vector<std::vector<int>> qubit_lists,
    int ntrials,
    int shots = 1000
    );

size_t calculate_quantum_volume(
    QCloudMachine* qvm,
    std::vector<std::vector<int>> qubit_lists,
    int ntrials,
    int shots = 1000
    );

std::map<int, double> single_qubit_rb(
    NoiseQVM* qvm,
    Qubit* qbit,
    const std::vector<int>& clifford_range,
    int num_circuits,
    int shots,
    const std::vector<QGate>& interleaved_gates = {}
    );

std::map<int, double> double_qubit_rb(
    NoiseQVM* qvm,
    Qubit* qbit0,
    Qubit* qbit1,
    const std::vector<int>& clifford_range,
    int num_circuits,
    int shots,
    const std::vector<QGate>& interleaved_gates = {}
    );

std::map<int, double> single_qubit_rb(
    QCloudMachine* qvm,
    Qubit* qbit,
    const std::vector<int>& clifford_range,
    int num_circuits,
    int shots,
    const std::vector<QGate>& interleaved_gates = {}
    );

std::map<int, double> double_qubit_rb(
    QCloudMachine* qvm,
    Qubit* qbit0,
    Qubit* qbit1,
    const std::vector<int>& clifford_range,
    int num_circuits,
    int shots,
    const std::vector<QGate>& interleaved_gates = {}
    );

std::string UnicodeToUTF8(const std::wstring& wstr);
std::wstring utf8ToWstring(const std::string& str);
std::string ulongToUtf8(unsigned long val);
void initConsole();

int get_wide_char_pos(
    const std::string& str,
    int start_pos
    );

void utf8_fit_to_gbk(std::string& utf8_str);
std::string fit_to_gbk(std::string& utf8_str);

std::string 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 draw_qprog(
    QProg prog,
    LayeredTopoSeq& m_layer_info,
    uint32_t length = 100,
    bool b_out_put_to_file = false
    );

std::string 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& operator << (std::ostream& out, QProg prog);
QProg qcodar_match_by_simple_type(QProg prog, QVec& qv, QuantumMachine* machine, size_t m = 2, size_t n = 4, size_t run_times = 5);

} // namespace QPanda

Detailed Documentation

Typedefs

typedef std::function<int(std::vector<std::string>&, std::vector<std::string>&)> MetadataValidity_cb

typedef MetadataValidity_cb that add all functions of metadata validity

Global Variables

const int kInfinite = 0xffff

Int infinite.

const int kError = -1

Error identifier.

Global Functions

DLLEXPORT PauliOperator BravyiKitaevTransform(
    const FermionOperator& fermion,
    std::vector<Eigen::MatrixXi> BK
    )

BravyiKitaev transform from FermionOperator to PauliOperator.

Parameters:

FermionOperator&	fermion operator
std::vector<Eigen::MatrixXi>	BK

Returns:

PauliOperator

See also:

FermionOperator

PauliOperator

ClassicalCondition operator + (cbit_size_t value, ClassicalCondition class_cond)

Overload operator +.

Parameters:

value	cbit_size_t type left operand
class_cond	ClassicalCondition type right operand

Returns:

ClassicalCondition

ClassicalCondition operator + (ClassicalCondition left_operand, ClassicalCondition right_operand)

Uverload operator +.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator + (ClassicalCondition left_operand, cbit_size_t right_operand)

Overload operator +.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator - (ClassicalCondition left_operand, ClassicalCondition right_operand)

Overload operator -.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator - (ClassicalCondition left_operand, cbit_size_t right_operand)

Overload operator -.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator - (cbit_size_t value, ClassicalCondition class_cond)

Overload operator -.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator * (ClassicalCondition, ClassicalCondition)

Overload operator *.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator * (ClassicalCondition, cbit_size_t)

Overload operator *.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator * (cbit_size_t value, ClassicalCondition class_cond)

Overload operator -.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator/ (ClassicalCondition, ClassicalCondition)

Overload operator /.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator/ (ClassicalCondition, cbit_size_t)

Overload operator /.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator/ (cbit_size_t value, ClassicalCondition class_cond)

Overload operator /.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator == (ClassicalCondition, ClassicalCondition)

Overload operator ==.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator == (ClassicalCondition, cbit_size_t)

Overload operator ==.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator == (cbit_size_t value, ClassicalCondition class_cond)

Overload operator ==.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator != (ClassicalCondition, ClassicalCondition)

Overload operator !=.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator != (ClassicalCondition, cbit_size_t)

Overload operator !=.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator != (cbit_size_t value, ClassicalCondition classical_cond)

Overload operator !=.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator && (ClassicalCondition, ClassicalCondition)

Overload operator &&.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator && (ClassicalCondition, cbit_size_t)

Overload operator &&.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator && (cbit_size_t value, ClassicalCondition classical_cond)

Overload operator &&.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator|| (ClassicalCondition, ClassicalCondition)

Overload operator ||.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator|| (ClassicalCondition, cbit_size_t)

Overload operator ||.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator|| (cbit_size_t value, ClassicalCondition classical_cond)

Overload operator ||.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator > (ClassicalCondition, ClassicalCondition)

Overload operator >

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator > (ClassicalCondition, cbit_size_t)

Overload operator >

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator > (cbit_size_t value, ClassicalCondition class_cond)

Overload operator >

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator >= (ClassicalCondition, ClassicalCondition)

Overload operator >=.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator >= (ClassicalCondition, cbit_size_t)

Overload operator >=.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator >= (cbit_size_t value, ClassicalCondition class_cond)

Overload operator >=.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator < (ClassicalCondition, ClassicalCondition)

Overload operator <.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator < (ClassicalCondition, cbit_size_t)

Overload operator <.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator < (cbit_size_t value, ClassicalCondition class_cond)

Overload operator <.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator <= (ClassicalCondition, ClassicalCondition)

Overload operator <=.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator <= (ClassicalCondition, cbit_size_t)

Overload operator <=.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator <= (cbit_size_t value, ClassicalCondition class_cond)

Overload operator <=.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator ! (ClassicalCondition)

Overload operator !

Parameters:

right_operand

right operand

Returns:

ClassicalCondition

QGate iSWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second)

Construct a new quantum iSWAP gate.

Parameters:

Qubit*	control qubit
Qubit*	target qubit

Returns:

QPanda::QGate quantum gate

QGate iSWAP(int control_qaddr, int target_qaddr)

Construct a new quantum iSWAP gate.

Parameters:

int	qaddr control qubit phy addr
int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

Qubit* get_qubit_by_phyaddr(int qaddr)

Get Qubit by physics addr.

Parameters:

int	qaddr target qubit phy addr

Returns:

Qubit*

QVec get_qubits_by_phyaddrs(const std::vector<int>& qaddrs)

Get Qubit vector by physics addr vector.

Parameters:

const

std::vector<int>& qubits physical address vector

Returns:

Qubit*

std::map<int, double> double_gate_xeb(
    NoiseQVM* qvm,
    Qubit* qbit0,
    Qubit* qbit1,
    const std::vector<int>& range,
    int num_circuits,
    int shots,
    GateType gt = GateType::CZ_GATE
    )

calculate double gate xeb

Parameters:

NoiseQVM*	noise quantum machine
Qubit*	qubit0
Qubit*	qubit1
const	std::vector<int>& number of layer
int	number of circuit per layer
int	run number
GateType	gate type

Returns:

std::map<int, double> xeb result of each layer

std::map<int, double> double_gate_xeb(
    QCloudMachine* qvm,
    Qubit* qbit0,
    Qubit* qbit1,
    const std::vector<int>& range,
    int num_circuits,
    int shots,
    GateType gt = GateType::CZ_GATE
    )

calculate double gate xeb

Parameters:

QCloudMachine*	cloud quantum machine
Qubit*	qubit0
Qubit*	qubit1
const	std::vector<int>& number of layer
int	number of circuit per layer
int	run number
GateType	gate type

Returns:

std::map<int, double> xeb result of each layer

bool judge_prog_operate_target_qubts(
    QProg prog,
    const QCircuitParam& cir_param,
    const std::vector<int>& qubits_vec
    )

Judge whether the prog is related to the target qubits.

Parameters:

QProg	the target prog
cir_param&	QCircuit param
std::vector<int>&	the appointed qubits vector

Returns:

if the prog have operated any qubit in qubits_vec return true, or else return false

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

Verify the validity of double quantum gates.

Parameters:

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

Returns:

int double quantum gate type

template <typename _Ty>
size_t getUnsupportQGateNum(
    _Ty node,
    const std::vector<std::vector<std::string>>& gates
    )

Count quantum program unsupported gate numner.

Parameters:

_Ty&	quantum program, quantum circuit, quantum while or quantum if
const	std::vector<std::vector<std::string>>& support gates

Returns:

size_t Unsupported QGate number

size_t calculate_quantum_volume(
    NoiseQVM* qvm,
    std::vector<std::vector<int>> qubit_lists,
    int ntrials,
    int shots = 1000
    )

calculate quantum volume

Parameters:

NoiseQVM*	noise quantum machine
std::vector	<std::vector<int>> qubit_lists, eg: {{1,2}, {1,2,3,4,5}}
const	std::vector<int>& number of layer
int	number of random iterations
int	shots

Returns:

size_t quantum volume

size_t calculate_quantum_volume(
    QCloudMachine* qvm,
    std::vector<std::vector<int>> qubit_lists,
    int ntrials,
    int shots = 1000
    )

calculate quantum volume

Parameters:

QCloudMachine*	real chip
std::vector	<std::vector<int>> qubit_lists, eg: {{1,2}, {1,2,3,4,5}}
const	std::vector<int>& number of layer
int	number of random iterations
int	shots

Returns:

size_t quantum volume

std::map<int, double> single_qubit_rb(
    NoiseQVM* qvm,
    Qubit* qbit,
    const std::vector<int>& clifford_range,
    int num_circuits,
    int shots,
    const std::vector<QGate>& interleaved_gates = {}
    )

single gate rb experiment

Parameters:

NoiseQVM*	noise quantum machine
Qubit*	qubit
const	std::vector<int>& number of layer
int	number of circuit per layer
int	run number
const	std::vector<QGate> interleaved gates

Returns:

std::map<int, double> rb result of each layer

std::map<int, double> double_qubit_rb(
    NoiseQVM* qvm,
    Qubit* qbit0,
    Qubit* qbit1,
    const std::vector<int>& clifford_range,
    int num_circuits,
    int shots,
    const std::vector<QGate>& interleaved_gates = {}
    )

single gate rb experiment

Parameters:

NoiseQVM*	noise quantum machine
Qubit*	qubit0
Qubit*	qubit1
const	std::vector<int>& number of layer
int	number of circuit per layer
int	run number
const	std::vector<QGate> interleaved gates

Returns:

std::map<int, double> rb result of each layer

std::map<int, double> single_qubit_rb(
    QCloudMachine* qvm,
    Qubit* qbit,
    const std::vector<int>& clifford_range,
    int num_circuits,
    int shots,
    const std::vector<QGate>& interleaved_gates = {}
    )

single gate rb experiment

Parameters:

QCloudMachine*	cloud quantum machine
Qubit*	qubit
const	std::vector<int>& number of layer
int	number of circuit per layer
int	run number
const	std::vector<QGate> interleaved gates

Returns:

std::map<int, double> rb result of each layer

std::map<int, double> double_qubit_rb(
    QCloudMachine* qvm,
    Qubit* qbit0,
    Qubit* qbit1,
    const std::vector<int>& clifford_range,
    int num_circuits,
    int shots,
    const std::vector<QGate>& interleaved_gates = {}
    )

single gate rb experiment

Parameters:

QCloudMachine*	cloud quantum machine
Qubit*	qubit0
Qubit*	qubit1
const	std::vector<int>& number of layer
int	number of circuit per layer
int	run number
const	std::vector<QGate> interleaved gates

Returns:

std::map<int, double> rb result of each layer

std::string UnicodeToUTF8(const std::wstring& wstr)

convert unicode string to UTF8 string

Parameters:

std::wstring&

the source wstring encoded by Unicode

Returns:

string Converted String

std::wstring utf8ToWstring(const std::string& str)

convert UTF8 string to wide string

Parameters:

std::string&

the source string

Returns:

wstring Converted wide String

std::string ulongToUtf8(unsigned long val)

convert unsigned long to string

Parameters:

unsigned long

the source val

Returns:

std::string Converted string

void initConsole()

set windows console to utf-8 encode