From 2281f07b600a32a97a2463c1f0ee910148cc8194 Mon Sep 17 00:00:00 2001 From: wangjing Date: Sat, 31 Jul 2021 15:16:49 +0800 Subject: [PATCH] update 2.1.7 --- Core/Core.cpp | 15 +- Core/QuantumCircuit/QGate.cpp | 580 ++-- Core/QuantumCircuit/QuantumGate.cpp | 25 + Core/QuantumCircuit/QuantumMeasure.cpp | 32 + Core/Utilities/QProgInfo/QuantumVolume.cpp | 8 +- Core/VirtualQuantumProcessor/CPUImplQPU.cpp | 166 +- include/Core/Core.h | 9 +- include/Core/QuantumCircuit/QGate.h | 78 + include/Core/QuantumCircuit/QGlobalVariable.h | 2 + include/Core/QuantumCircuit/QuantumGate.h | 46 + include/Core/QuantumCircuit/QuantumMeasure.h | 14 +- .../Utilities/Tools/QuantumStateTomography.h | 1 + .../Core/VirtualQuantumProcessor/CPUImplQPU.h | 33 + pyQPandaCpp/pyQPanda.Core/pyqpanda.core.cpp | 2725 ++++++++++------- 14 files changed, 2326 insertions(+), 1408 deletions(-) diff --git a/Core/Core.cpp b/Core/Core.cpp index 31d1258c..0d714166 100644 --- a/Core/Core.cpp +++ b/Core/Core.cpp @@ -431,20 +431,7 @@ map QPanda::quickMeasure(QVec vQubit, int shots) return temp->quickMeasure(vQubit, shots); } -QProg QPanda::MeasureAll(QVec vQubit, vector vCBit) -{ - QProg qprog = CreateEmptyQProg(); - if (vQubit.size() != vCBit.size()) - { - QCERR("vQubit != vCBit"); - throw invalid_argument("vQubit != vCBit"); - } - for (size_t i = 0; i < vQubit.size(); i++) - { - qprog << Measure(vQubit[i], vCBit[i]); - } - return qprog; -} + QStat QPanda::getQState() { diff --git a/Core/QuantumCircuit/QGate.cpp b/Core/QuantumCircuit/QGate.cpp index fc2cfbb9..b2543a61 100644 --- a/Core/QuantumCircuit/QGate.cpp +++ b/Core/QuantumCircuit/QGate.cpp @@ -502,6 +502,41 @@ QCircuit QPanda::U1(const QVec& qubits, double angle) return cir; } +QGate QPanda::P(Qubit* qubit, double angle) +{ + string name = "P"; + return _gs_pGateNodeFactory->getGateNode(name, { qubit }, angle); +} + +QCircuit QPanda::P(const QVec& qubits, double angle) +{ + string name = "P"; + QCircuit cir = QCircuit(); + for (auto &qubit : qubits) + { + cir << _gs_pGateNodeFactory->getGateNode(name, { qubit }, angle); + } + + return cir; +} + +QGate QPanda::P(int qaddr, double angle) +{ + return P(get_qubit_by_phyaddr(qaddr), angle); +} + +QCircuit QPanda::P(const std::vector& qaddrs, double angle) +{ + QCircuit cir = QCircuit(); + for (auto &qaddr : qaddrs) + { + cir << P(get_qubit_by_phyaddr(qaddr), angle); + } + + return cir; +} + + QGate QPanda::U2(Qubit* qubit, double phi, double lambda) { string name = "U2"; @@ -1198,30 +1233,27 @@ QCircuit QPanda::CR(const QVec& targitBits_first, const QVec& targitBits_second, return cir; } -QGate QPanda::SqiSWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second) +QGate QPanda::CR(int control_qaddr, int target_qaddr, double theta) { - string name = "SQISWAP"; - return _gs_pGateNodeFactory->getGateNode(name, - { targitBit_fisrt,targitBit_second }); + return CR(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr), theta); } -QCircuit QPanda::SqiSWAP(const QVec& targitBits_first, const QVec& targitBits_second) +QCircuit QPanda::CR(const std::vector& control_qaddrs, const std::vector& target_qaddrs, double theta) { - if (targitBits_first.size() == 0 || targitBits_second.size() == 0) + if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) { QCERR("qubit_vector err"); throw invalid_argument("qubit_vector err"); } - string name = "SQISWAP"; - auto cir = QCircuit(); - if (targitBits_first.size() == targitBits_second.size()) + QCircuit cir = QCircuit(); + if (control_qaddrs.size() == target_qaddrs.size()) { - for (int i = 0; i < targitBits_first.size(); ++i) + for (int i = 0; i < control_qaddrs.size(); ++i) { - if (targitBits_first[i] != targitBits_second[i]) + if (control_qaddrs[i] != target_qaddrs[i]) { - cir << _gs_pGateNodeFactory->getGateNode(name, { targitBits_first[i], targitBits_second[i] }); + cir << CR(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i]), theta); } else { @@ -1239,14 +1271,14 @@ QCircuit QPanda::SqiSWAP(const QVec& targitBits_first, const QVec& targitBits_se return cir; } -QGate QPanda::SWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second) +QGate QPanda::SqiSWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second) { - string name = "SWAP"; + string name = "SQISWAP"; return _gs_pGateNodeFactory->getGateNode(name, { targitBit_fisrt,targitBit_second }); } -QCircuit QPanda::SWAP(const QVec& targitBits_first, const QVec& targitBits_second) +QCircuit QPanda::SqiSWAP(const QVec& targitBits_first, const QVec& targitBits_second) { if (targitBits_first.size() == 0 || targitBits_second.size() == 0) { @@ -1254,7 +1286,7 @@ QCircuit QPanda::SWAP(const QVec& targitBits_first, const QVec& targitBits_secon throw invalid_argument("qubit_vector err"); } - string name = "SWAP"; + string name = "SQISWAP"; auto cir = QCircuit(); if (targitBits_first.size() == targitBits_second.size()) { @@ -1280,35 +1312,34 @@ QCircuit QPanda::SWAP(const QVec& targitBits_first, const QVec& targitBits_secon return cir; } -QGate QPanda::CNOT(Qubit* control_qubit, Qubit* target_qubit) +QGate QPanda::SqiSWAP(int control_qaddr, int target_qaddr) { - string name = "CNOT"; - return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }); + return SqiSWAP(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr)); } -QCircuit QPanda::CNOT(const QVec &control_qubits, const QVec &target_qubits) +QCircuit QPanda::SqiSWAP(const std::vector& control_qaddrs, const std::vector& target_qaddrs) { - if (control_qubits.size() == 0 || target_qubits.size() == 0) + if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) { QCERR("qubit_vector err"); throw invalid_argument("qubit_vector err"); } - string name = "CNOT"; - auto cir = QCircuit(); - if (control_qubits.size() == target_qubits.size()) + + QCircuit cir = QCircuit(); + if (control_qaddrs.size() == target_qaddrs.size()) { - for (int i = 0; i < control_qubits.size(); ++i) + for (int i = 0; i < control_qaddrs.size(); ++i) { - if(control_qubits[i]!=target_qubits[i]) + if (control_qaddrs[i] != target_qaddrs[i]) { - cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] }); + cir << SqiSWAP(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i])); } else { QCERR("double_gate qubit err"); throw invalid_argument("double_gate qubit"); } - } + } } else { @@ -1319,29 +1350,30 @@ QCircuit QPanda::CNOT(const QVec &control_qubits, const QVec &target_qubits) return cir; } -QGate QPanda::CZ(Qubit* control_qubit, Qubit* target_qubit) +QGate QPanda::SWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second) { - string name = "CZ"; - return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }); + string name = "SWAP"; + return _gs_pGateNodeFactory->getGateNode(name, + { targitBit_fisrt,targitBit_second }); } -QCircuit QPanda::CZ(const QVec& control_qubits, const QVec &target_qubits) +QCircuit QPanda::SWAP(const QVec& targitBits_first, const QVec& targitBits_second) { - if (control_qubits.size() == 0 || target_qubits.size() == 0) + if (targitBits_first.size() == 0 || targitBits_second.size() == 0) { QCERR("qubit_vector err"); throw invalid_argument("qubit_vector err"); } - string name = "CZ"; - QCircuit cir = QCircuit(); - if (control_qubits.size() == target_qubits.size()) + string name = "SWAP"; + auto cir = QCircuit(); + if (targitBits_first.size() == targitBits_second.size()) { - for (int i = 0; i < control_qubits.size(); ++i) + for (int i = 0; i < targitBits_first.size(); ++i) { - if (control_qubits[i] != target_qubits[i]) + if (targitBits_first[i] != targitBits_second[i]) { - cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] }); + cir << _gs_pGateNodeFactory->getGateNode(name, { targitBits_first[i], targitBits_second[i] }); } else { @@ -1359,90 +1391,65 @@ QCircuit QPanda::CZ(const QVec& control_qubits, const QVec &target_qubits) return cir; } -QGate QPanda::U4(double alpha, double beta, double gamma, double delta, Qubit* qubit) -{ - string name = "U4"; - return _gs_pGateNodeFactory->getGateNode(name, { qubit }, alpha, beta, gamma, delta); -} - -QGate QPanda::U4(QStat& matrix, Qubit* qubit) -{ - string name = "U4"; - return _gs_pGateNodeFactory->getGateNode(name, { qubit }, matrix); -} - -/* new interface */ -QGate QPanda::U4(Qubit* qubit, QStat& matrix) +QGate QPanda::SWAP(int control_qaddr, int target_qaddr) { - string name = "U4"; - return _gs_pGateNodeFactory->getGateNode(name, { qubit }, matrix); + return SWAP(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr)); } -QCircuit QPanda::U4(const QVec &qubits, QStat& martix) +QCircuit QPanda::SWAP(const std::vector& control_qaddrs, const std::vector& target_qaddrs) { - string name = "U4"; - QCircuit cir = QCircuit(); - for (auto &qubit : qubits) + if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) { - cir << _gs_pGateNodeFactory->getGateNode(name, { qubit }); + QCERR("qubit_vector err"); + throw invalid_argument("qubit_vector err"); } - return cir; -} - -QGate QPanda::U4(Qubit* qubit, double alpha, double beta, double gamma, double delta) -{ - string name = "U4"; - return _gs_pGateNodeFactory->getGateNode(name, { qubit }, alpha, beta, gamma, delta); -} - -QCircuit QPanda::U4(const QVec& qubits, double alpha, double beta, double gamma, double delta) -{ - string name = "U4"; QCircuit cir = QCircuit(); - for (auto &qubit : qubits) + if (control_qaddrs.size() == target_qaddrs.size()) { - cir << _gs_pGateNodeFactory->getGateNode(name, { qubit }); + for (int i = 0; i < control_qaddrs.size(); ++i) + { + if (control_qaddrs[i] != target_qaddrs[i]) + { + cir << SWAP(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i])); + } + else + { + QCERR("double_gate qubit err"); + throw invalid_argument("double_gate qubit"); + } + } + } + else + { + QCERR("qubit_vector size err"); + throw invalid_argument("qubit_vector size"); } return cir; } -/** Construct QGate by Qubit physics addr */ - -QGate QPanda::CU(double alpha, - double beta, - double gamma, - double delta, - Qubit* control_qubit, - Qubit* target_qubit) +QGate QPanda::iSWAP(int control_qaddr, int target_qaddr) { - string name = "CU"; - return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }, alpha, beta, gamma, delta); + return iSWAP(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr)); } -QCircuit QPanda::CU(double alpha, - double beta, - double gamma, - double delta, - const QVec& control_qubits, - const QVec& target_qubits) +QCircuit QPanda::iSWAP(const std::vector& control_qaddrs, const std::vector& target_qaddrs) { - if (control_qubits.size() == 0 || target_qubits.size() == 0) + if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) { QCERR("qubit_vector err"); throw invalid_argument("qubit_vector err"); } - string name = "CU"; QCircuit cir = QCircuit(); - if (control_qubits.size() == target_qubits.size()) + if (control_qaddrs.size() == target_qaddrs.size()) { - for (int i = 0; i < control_qubits.size(); ++i) + for (int i = 0; i < control_qaddrs.size(); ++i) { - if (control_qubits[i] != target_qubits[i]) + if (control_qaddrs[i] != target_qaddrs[i]) { - cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] }, alpha, beta, gamma, delta); + cir << iSWAP(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i])); } else { @@ -1460,28 +1467,27 @@ QCircuit QPanda::CU(double alpha, return cir; } -QGate QPanda::CU(QStat& matrix, Qubit* control_qubit, Qubit* target_qubit) +QGate QPanda::iSWAP(int control_qaddr, int target_qaddr, double theta) { - string name = "CU"; - return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }, matrix); + return iSWAP(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr), theta); } -QCircuit QPanda::CU(QStat& matrix, const QVec& control_qubits, const QVec& target_qubits) +QCircuit QPanda::iSWAP(const std::vector& control_qaddrs, const std::vector& target_qaddrs, double theta) { - if (control_qubits.size() == 0 || target_qubits.size() == 0) + if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) { QCERR("qubit_vector err"); throw invalid_argument("qubit_vector err"); } - string name = "CU"; + QCircuit cir = QCircuit(); - if (control_qubits.size() == target_qubits.size()) + if (control_qaddrs.size() == target_qaddrs.size()) { - for (int i = 0; i < control_qubits.size(); ++i) + for (int i = 0; i < control_qaddrs.size(); ++i) { - if (control_qubits[i] != target_qubits[i]) + if (control_qaddrs[i] != target_qaddrs[i]) { - cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] }, matrix); + cir << iSWAP(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i]), theta); } else { @@ -1499,55 +1505,36 @@ QCircuit QPanda::CU(QStat& matrix, const QVec& control_qubits, const QVec& targe return cir; } -QGate QPanda::QDouble(QStat& matrix, Qubit* qubit1, Qubit* qubit2) -{ - string name = ":QDoubleGate"; - return _gs_pGateNodeFactory->getGateNode(name, { qubit1, qubit2 }, matrix); -} - -QGate QPanda::Toffoli(Qubit * control_fisrt, Qubit * control_second, Qubit * target) -{ - auto gate = X(target); - gate.setControl({ control_fisrt, control_second }); - return gate; -} - -QGate QPanda::oracle(QVec qubits, std::string oracle_name) -{ - string name = "OracularGate"; - return _gs_pGateNodeFactory->getGateNode(name, qubits, oracle_name); -} -QGate QPanda::QDouble(Qubit* qubit1, Qubit* qubit2, QStat& matrix) +QGate QPanda::CNOT(Qubit* control_qubit, Qubit* target_qubit) { - string name = "QDoubleGate"; - return _gs_pGateNodeFactory->getGateNode(name, { qubit1, qubit2 }, matrix); + string name = "CNOT"; + return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }); } -QCircuit QPanda::QDouble(const QVec& qubit1, const QVec& qubit2, QStat& matrix) +QCircuit QPanda::CNOT(const QVec &control_qubits, const QVec &target_qubits) { - if (qubit1.size() == 0 || qubit2.size() == 0) + if (control_qubits.size() == 0 || target_qubits.size() == 0) { QCERR("qubit_vector err"); throw invalid_argument("qubit_vector err"); } - - string name = "QDoubleGate"; - QCircuit cir = QCircuit(); - if (qubit1.size() == qubit2.size()) + string name = "CNOT"; + auto cir = QCircuit(); + if (control_qubits.size() == target_qubits.size()) { - for (int i = 0; i < qubit1.size(); ++i) + for (int i = 0; i < control_qubits.size(); ++i) { - if (qubit1[i] != qubit2[i]) + if(control_qubits[i]!=target_qubits[i]) { - cir << _gs_pGateNodeFactory->getGateNode(name, { qubit1[i] }, qubit2[i], matrix); + cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] }); } else { QCERR("double_gate qubit err"); throw invalid_argument("double_gate qubit"); } - } + } } else { @@ -1558,35 +1545,27 @@ QCircuit QPanda::QDouble(const QVec& qubit1, const QVec& qubit2, QStat& matrix) return cir; } -QGate QPanda::CU(Qubit* control_qubit, - Qubit* target_qubit, - double alpha, double beta, - double gamma, double delta) +QGate QPanda::CNOT(int control_qaddr, int target_qaddr) { - string name = "CU"; - return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }, alpha, beta, gamma, delta); + return CNOT(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr)); } -QCircuit QPanda::CU(const QVec& control_qubits, - const QVec& target_qubits, - double alpha, double beta, - double gamma, double delta) +QCircuit QPanda::CNOT(const std::vector& control_qaddrs, const std::vector& target_qaddrs) { - if (control_qubits.size() == 0 || target_qubits.size() == 0) + if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) { QCERR("qubit_vector err"); throw invalid_argument("qubit_vector err"); } - string name = "CU"; QCircuit cir = QCircuit(); - if (control_qubits.size() == target_qubits.size()) + if (control_qaddrs.size() == target_qaddrs.size()) { - for (int i = 0; i < control_qubits.size(); i++) + for (int i = 0; i < control_qaddrs.size(); ++i) { - if (control_qubits[i] != target_qubits[i]) + if (control_qaddrs[i] != target_qaddrs[i]) { - cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] }, alpha, beta, gamma, delta); + cir << CNOT(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i])); } else { @@ -1604,13 +1583,14 @@ QCircuit QPanda::CU(const QVec& control_qubits, return cir; } -QGate QPanda::CU(Qubit* control_qubit, Qubit* target_qubit, QStat& matrix) + +QGate QPanda::CZ(Qubit* control_qubit, Qubit* target_qubit) { - string name = "CU"; - return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }, matrix); + string name = "CZ"; + return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }); } -QCircuit QPanda::CU(const QVec& control_qubits, const QVec& target_qubits, QStat& matrix) +QCircuit QPanda::CZ(const QVec& control_qubits, const QVec &target_qubits) { if (control_qubits.size() == 0 || target_qubits.size() == 0) { @@ -1618,15 +1598,15 @@ QCircuit QPanda::CU(const QVec& control_qubits, const QVec& target_qubits, QStat throw invalid_argument("qubit_vector err"); } - string name = "CU"; + string name = "CZ"; QCircuit cir = QCircuit(); if (control_qubits.size() == target_qubits.size()) { - for (int i = 0; i < control_qubits.size(); i++) + for (int i = 0; i < control_qubits.size(); ++i) { if (control_qubits[i] != target_qubits[i]) { - cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] }, matrix); + cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] }); } else { @@ -1644,12 +1624,12 @@ QCircuit QPanda::CU(const QVec& control_qubits, const QVec& target_qubits, QStat return cir; } -QGate QPanda::CNOT(int control_qaddr, int target_qaddr) +QGate QPanda::CZ(int control_qaddr, int target_qaddr) { - return CNOT(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr)); + return CZ(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr)); } -QCircuit QPanda::CNOT(const std::vector& control_qaddrs, const std::vector& target_qaddrs) +QCircuit QPanda::CZ(const std::vector& control_qaddrs, const std::vector& target_qaddrs) { if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) { @@ -1664,7 +1644,7 @@ QCircuit QPanda::CNOT(const std::vector& control_qaddrs, const std::vector< { if (control_qaddrs[i] != target_qaddrs[i]) { - cir << CNOT(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i])); + cir << CZ(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i])); } else { @@ -1682,27 +1662,29 @@ QCircuit QPanda::CNOT(const std::vector& control_qaddrs, const std::vector< return cir; } -QGate QPanda::CZ(int control_qaddr, int target_qaddr) +QGate QPanda::CP(Qubit* control_qubit, Qubit* target_qubit, double theta) { - return CZ(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr)); + string name = "CP"; + return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }, theta); } -QCircuit QPanda::CZ(const std::vector& control_qaddrs, const std::vector& target_qaddrs) +QCircuit QPanda::CP(const QVec& control_qubits, const QVec &target_qubits, double theta) { - if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) + if (control_qubits.size() == 0 || target_qubits.size() == 0) { QCERR("qubit_vector err"); throw invalid_argument("qubit_vector err"); } + string name = "CP"; QCircuit cir = QCircuit(); - if (control_qaddrs.size() == target_qaddrs.size()) + if (control_qubits.size() == target_qubits.size()) { - for (int i = 0; i < control_qaddrs.size(); ++i) + for (int i = 0; i < control_qubits.size(); ++i) { - if (control_qaddrs[i] != target_qaddrs[i]) + if (control_qubits[i] != target_qubits[i]) { - cir << CZ(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i])); + cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] },theta); } else { @@ -1720,12 +1702,12 @@ QCircuit QPanda::CZ(const std::vector& control_qaddrs, const std::vector& control_qaddrs, const std::vector& target_qaddrs) +QCircuit QPanda::CP(const std::vector& control_qaddrs, const std::vector& target_qaddrs, double theta) { if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) { @@ -1740,7 +1722,7 @@ QCircuit QPanda::iSWAP(const std::vector& control_qaddrs, const std::vector { if (control_qaddrs[i] != target_qaddrs[i]) { - cir << iSWAP(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i])); + cir << CP(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i]), theta); } else { @@ -1758,27 +1740,91 @@ QCircuit QPanda::iSWAP(const std::vector& control_qaddrs, const std::vector return cir; } -QGate QPanda::iSWAP(int control_qaddr, int target_qaddr, double theta) + +QGate QPanda::U4(double alpha, double beta, double gamma, double delta, Qubit* qubit) { - return iSWAP(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr), theta); + string name = "U4"; + return _gs_pGateNodeFactory->getGateNode(name, { qubit }, alpha, beta, gamma, delta); } -QCircuit QPanda::iSWAP(const std::vector& control_qaddrs, const std::vector& target_qaddrs, double theta) +QGate QPanda::U4(QStat& matrix, Qubit* qubit) { - if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) + string name = "U4"; + return _gs_pGateNodeFactory->getGateNode(name, { qubit }, matrix); +} + +/* new interface */ +QGate QPanda::U4(Qubit* qubit, QStat& matrix) +{ + string name = "U4"; + return _gs_pGateNodeFactory->getGateNode(name, { qubit }, matrix); +} + +QCircuit QPanda::U4(const QVec &qubits, QStat& martix) +{ + string name = "U4"; + QCircuit cir = QCircuit(); + for (auto &qubit : qubits) + { + cir << _gs_pGateNodeFactory->getGateNode(name, { qubit }); + } + + return cir; +} + +QGate QPanda::U4(Qubit* qubit, double alpha, double beta, double gamma, double delta) +{ + string name = "U4"; + return _gs_pGateNodeFactory->getGateNode(name, { qubit }, alpha, beta, gamma, delta); +} + +QCircuit QPanda::U4(const QVec& qubits, double alpha, double beta, double gamma, double delta) +{ + string name = "U4"; + QCircuit cir = QCircuit(); + for (auto &qubit : qubits) + { + cir << _gs_pGateNodeFactory->getGateNode(name, { qubit }); + } + + return cir; +} + +/** Construct QGate by Qubit physics addr */ + +QGate QPanda::CU(double alpha, + double beta, + double gamma, + double delta, + Qubit* control_qubit, + Qubit* target_qubit) +{ + string name = "CU"; + return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }, alpha, beta, gamma, delta); +} + +QCircuit QPanda::CU(double alpha, + double beta, + double gamma, + double delta, + const QVec& control_qubits, + const QVec& target_qubits) +{ + if (control_qubits.size() == 0 || target_qubits.size() == 0) { QCERR("qubit_vector err"); throw invalid_argument("qubit_vector err"); } + string name = "CU"; QCircuit cir = QCircuit(); - if (control_qaddrs.size() == target_qaddrs.size()) + if (control_qubits.size() == target_qubits.size()) { - for (int i = 0; i < control_qaddrs.size(); ++i) + for (int i = 0; i < control_qubits.size(); ++i) { - if (control_qaddrs[i] != target_qaddrs[i]) + if (control_qubits[i] != target_qubits[i]) { - cir << iSWAP(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i]), theta); + cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] }, alpha, beta, gamma, delta); } else { @@ -1796,27 +1842,28 @@ QCircuit QPanda::iSWAP(const std::vector& control_qaddrs, const std::vector return cir; } -QGate QPanda::CR(int control_qaddr, int target_qaddr, double theta) +QGate QPanda::CU(QStat& matrix, Qubit* control_qubit, Qubit* target_qubit) { - return CR(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr), theta); + string name = "CU"; + return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }, matrix); } -QCircuit QPanda::CR(const std::vector& control_qaddrs, const std::vector& target_qaddrs, double theta) +QCircuit QPanda::CU(QStat& matrix, const QVec& control_qubits, const QVec& target_qubits) { - if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) + if (control_qubits.size() == 0 || target_qubits.size() == 0) { QCERR("qubit_vector err"); throw invalid_argument("qubit_vector err"); } - + string name = "CU"; QCircuit cir = QCircuit(); - if (control_qaddrs.size() == target_qaddrs.size()) + if (control_qubits.size() == target_qubits.size()) { - for (int i = 0; i < control_qaddrs.size(); ++i) + for (int i = 0; i < control_qubits.size(); ++i) { - if (control_qaddrs[i] != target_qaddrs[i]) + if (control_qubits[i] != target_qubits[i]) { - cir << CR(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i]), theta); + cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] }, matrix); } else { @@ -1834,27 +1881,48 @@ QCircuit QPanda::CR(const std::vector& control_qaddrs, const std::vectorgetGateNode(name, { qubit1, qubit2 }, matrix); } -QCircuit QPanda::SqiSWAP(const std::vector& control_qaddrs, const std::vector& target_qaddrs) +QGate QPanda::Toffoli(Qubit * control_fisrt, Qubit * control_second, Qubit * target) { - if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) + auto gate = X(target); + gate.setControl({ control_fisrt, control_second }); + return gate; +} + +QGate QPanda::oracle(QVec qubits, std::string oracle_name) +{ + string name = "OracularGate"; + return _gs_pGateNodeFactory->getGateNode(name, qubits, oracle_name); +} + +QGate QPanda::QDouble(Qubit* qubit1, Qubit* qubit2, QStat& matrix) +{ + string name = "QDoubleGate"; + return _gs_pGateNodeFactory->getGateNode(name, { qubit1, qubit2 }, matrix); +} + +QCircuit QPanda::QDouble(const QVec& qubit1, const QVec& qubit2, QStat& matrix) +{ + if (qubit1.size() == 0 || qubit2.size() == 0) { QCERR("qubit_vector err"); throw invalid_argument("qubit_vector err"); } + string name = "QDoubleGate"; QCircuit cir = QCircuit(); - if (control_qaddrs.size() == target_qaddrs.size()) + if (qubit1.size() == qubit2.size()) { - for (int i = 0; i < control_qaddrs.size(); ++i) + for (int i = 0; i < qubit1.size(); ++i) { - if (control_qaddrs[i] != target_qaddrs[i]) + if (qubit1[i] != qubit2[i]) { - cir << SqiSWAP(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i])); + cir << _gs_pGateNodeFactory->getGateNode(name, { qubit1[i] }, qubit2[i], matrix); } else { @@ -1872,12 +1940,12 @@ QCircuit QPanda::SqiSWAP(const std::vector& control_qaddrs, const std::vect return cir; } -QGate QPanda::SWAP(int control_qaddr, int target_qaddr) +QGate QPanda::QDouble(int control_qaddr, int target_qaddr, QStat& matrix) { - return SWAP(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr)); + return QDouble(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr), matrix); } -QCircuit QPanda::SWAP(const std::vector& control_qaddrs, const std::vector& target_qaddrs) +QCircuit QPanda::QDouble(const std::vector& control_qaddrs, const std::vector& target_qaddrs, QStat& matrix) { if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) { @@ -1892,7 +1960,7 @@ QCircuit QPanda::SWAP(const std::vector& control_qaddrs, const std::vector< { if (control_qaddrs[i] != target_qaddrs[i]) { - cir << SWAP(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i])); + cir << QDouble(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i]), matrix); } else { @@ -1910,59 +1978,76 @@ QCircuit QPanda::SWAP(const std::vector& control_qaddrs, const std::vector< return cir; } -QGate QPanda::U4(int qaddr, double alpha, double beta, double gamma, double delta) + +QGate QPanda::CU(Qubit* control_qubit, + Qubit* target_qubit, + double alpha, double beta, + double gamma, double delta) { - return U4(get_qubit_by_phyaddr(qaddr), alpha, beta, gamma, delta); + string name = "CU"; + return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }, alpha, beta, gamma, delta); } -QCircuit QPanda::U4(const std::vector& qaddrs, double alpha, double beta, double gamma, double delta) +QCircuit QPanda::CU(const QVec& control_qubits, + const QVec& target_qubits, + double alpha, double beta, + double gamma, double delta) { - QCircuit cir = QCircuit(); - for (auto &qaddr : qaddrs) + if (control_qubits.size() == 0 || target_qubits.size() == 0) { - cir << U4(get_qubit_by_phyaddr(qaddr), alpha, beta, gamma, delta); + QCERR("qubit_vector err"); + throw invalid_argument("qubit_vector err"); } - - return cir; -} -QGate QPanda::U4(int qaddr, QStat& matrix) -{ - return U4(get_qubit_by_phyaddr(qaddr), matrix); -} - -QCircuit QPanda::U4(const std::vector& qaddrs, QStat& martix) -{ + string name = "CU"; QCircuit cir = QCircuit(); - for (auto &qaddr : qaddrs) + if (control_qubits.size() == target_qubits.size()) { - cir << U4(get_qubit_by_phyaddr(qaddr), martix); + for (int i = 0; i < control_qubits.size(); i++) + { + if (control_qubits[i] != target_qubits[i]) + { + cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] }, alpha, beta, gamma, delta); + } + else + { + QCERR("double_gate qubit err"); + throw invalid_argument("double_gate qubit"); + } + } + } + else + { + QCERR("qubit_vector size err"); + throw invalid_argument("qubit_vector size"); } return cir; } -QGate QPanda::QDouble(int control_qaddr, int target_qaddr, QStat& matrix) +QGate QPanda::CU(Qubit* control_qubit, Qubit* target_qubit, QStat& matrix) { - return QDouble(get_qubit_by_phyaddr(control_qaddr), get_qubit_by_phyaddr(target_qaddr), matrix); + string name = "CU"; + return _gs_pGateNodeFactory->getGateNode(name, { control_qubit, target_qubit }, matrix); } -QCircuit QPanda::QDouble(const std::vector& control_qaddrs, const std::vector& target_qaddrs, QStat& matrix) +QCircuit QPanda::CU(const QVec& control_qubits, const QVec& target_qubits, QStat& matrix) { - if (control_qaddrs.size() == 0 || target_qaddrs.size() == 0) + if (control_qubits.size() == 0 || target_qubits.size() == 0) { QCERR("qubit_vector err"); throw invalid_argument("qubit_vector err"); } + string name = "CU"; QCircuit cir = QCircuit(); - if (control_qaddrs.size() == target_qaddrs.size()) + if (control_qubits.size() == target_qubits.size()) { - for (int i = 0; i < control_qaddrs.size(); ++i) + for (int i = 0; i < control_qubits.size(); i++) { - if (control_qaddrs[i] != target_qaddrs[i]) + if (control_qubits[i] != target_qubits[i]) { - cir << QDouble(get_qubit_by_phyaddr(control_qaddrs[i]), get_qubit_by_phyaddr(target_qaddrs[i]), matrix); + cir << _gs_pGateNodeFactory->getGateNode(name, { control_qubits[i], target_qubits[i] }, matrix); } else { @@ -2055,6 +2140,39 @@ QCircuit QPanda::CU(const std::vector& control_qaddrs, const std::vector& qaddrs, double alpha, double beta, double gamma, double delta) +{ + QCircuit cir = QCircuit(); + for (auto &qaddr : qaddrs) + { + cir << U4(get_qubit_by_phyaddr(qaddr), alpha, beta, gamma, delta); + } + + return cir; +} + +QGate QPanda::U4(int qaddr, QStat& matrix) +{ + return U4(get_qubit_by_phyaddr(qaddr), matrix); +} + +QCircuit QPanda::U4(const std::vector& qaddrs, QStat& martix) +{ + QCircuit cir = QCircuit(); + for (auto &qaddr : qaddrs) + { + cir << U4(get_qubit_by_phyaddr(qaddr), martix); + } + + return cir; +} + + QGate QPanda::Toffoli(int qaddr0, int qaddr1, int target_qaddr) { auto qpool = OriginQubitPool::get_instance(); diff --git a/Core/QuantumCircuit/QuantumGate.cpp b/Core/QuantumCircuit/QuantumGate.cpp index 69f92f63..01d2071e 100644 --- a/Core/QuantumCircuit/QuantumGate.cpp +++ b/Core/QuantumCircuit/QuantumGate.cpp @@ -203,6 +203,19 @@ Z::Z() gate_type = GateType::PAULI_Z_GATE; } +//P_Gate=[1 0;0 exp(i*angle)] +P::P(double angle) +{ + operation_num = 1; + alpha = angle / 2; + beta = angle; + gamma = 0; + delta = 0; + gate_matrix[3].real(cos(angle)); + gate_matrix[3].imag(1 * sin(angle)); + gate_type = GateType::P_GATE; +} + //RX(pi/2) gate X1::X1() { @@ -587,6 +600,18 @@ CZ::CZ() gate_type = GateType::CZ_GATE; } +CP::CP(double angle) +{ + operation_num = 2; + alpha = angle / 2; + beta = angle; + gamma = 0; + delta = 0; + gate_matrix[15].real(cos(angle)); + gate_matrix[15].imag(1 * sin(angle)); + gate_type = GateType::CP_GATE; +} + ISWAPTheta::ISWAPTheta(QuantumGate * gate_old) :QDoubleGate(gate_old) { if (gate_old->getGateType() != GateType::ISWAP_THETA_GATE) diff --git a/Core/QuantumCircuit/QuantumMeasure.cpp b/Core/QuantumCircuit/QuantumMeasure.cpp index 288e4c74..884d587f 100644 --- a/Core/QuantumCircuit/QuantumMeasure.cpp +++ b/Core/QuantumCircuit/QuantumMeasure.cpp @@ -16,6 +16,8 @@ limitations under the License. #include "QuantumMeasure.h" #include "Core/Utilities/QProgInfo/ConfigMap.h" +#include "Core/QuantumCircuit/QProgram.h" + USING_QPANDA using namespace std; QMeasure QPanda::Measure(Qubit * target_qubit,ClassicalCondition classical_cond) @@ -153,4 +155,34 @@ CBit * OriginMeasure::getCBit() const return m_target_cbit; } +QProg QPanda::MeasureAll(const QVec& vQubit, const std::vector& vCBit) +{ + QProg qprog = CreateEmptyQProg(); + if (vQubit.size() != vCBit.size()) + { + QCERR("vQubit != vCBit"); + throw invalid_argument("vQubit != vCBit"); + } + for (size_t i = 0; i < vQubit.size(); i++) + { + qprog << Measure(vQubit[i], vCBit[i]); + } + return qprog; +} + +QProg QPanda::MeasureAll(const std::vector& iQubit, const std::vector& cCBit) +{ + QProg qprog = CreateEmptyQProg(); + if (iQubit.size() != cCBit.size()) + { + QCERR("iQubit != cCBit"); + throw invalid_argument("iQubit != cCBit"); + } + for (size_t i = 0; i < iQubit.size(); i++) + { + qprog << Measure(iQubit[i], cCBit[i]); + } + return qprog; +} + REGISTER_MEASURE(OriginMeasure); diff --git a/Core/Utilities/QProgInfo/QuantumVolume.cpp b/Core/Utilities/QProgInfo/QuantumVolume.cpp index 73b0f11a..f41d02d7 100644 --- a/Core/Utilities/QProgInfo/QuantumVolume.cpp +++ b/Core/Utilities/QProgInfo/QuantumVolume.cpp @@ -245,12 +245,8 @@ void QuantumVolume::calcINoiseResult(std::vector >&circu for (int i = 0; i < stat_vec.size(); i++) { auto iter_res = result.find(stat_vec[i]); - if (iter_res == result.end()) - { - QCERR("find result error !"); - throw invalid_argument("find result error !"); - } - counts += iter_res->second; + if (iter_res != result.end()) + counts += iter_res->second; } m_heavy_output_counts.insert(std::pair , size_t >(key, counts)); } diff --git a/Core/VirtualQuantumProcessor/CPUImplQPU.cpp b/Core/VirtualQuantumProcessor/CPUImplQPU.cpp index 1acd9425..5bd6fe80 100644 --- a/Core/VirtualQuantumProcessor/CPUImplQPU.cpp +++ b/Core/VirtualQuantumProcessor/CPUImplQPU.cpp @@ -86,12 +86,9 @@ QError CPUImplQPU::pMeasure(Qnum& qnum, prob_tuple &probs, int select_max) QError CPUImplQPU::pMeasure(Qnum& qnum, prob_vec &probs) { probs.resize(1ll << qnum.size()); - const size_t probs_size = probs.size(); - double *probs_pointer = probs.data(); - size_t size = 1ll << m_qubit_num; stable_sort(qnum.begin(), qnum.end()); -//#pragma omp parallel for num_threads(_omp_thread_num(size)) reduction(+:probs_pointer[0:probs_size]) +#pragma omp parallel for num_threads(_omp_thread_num(size)) for (int64_t i = 0; i < size; i++) { size_t pmeasure_idx = 0; @@ -110,7 +107,12 @@ QError CPUImplQPU::pMeasure(Qnum& qnum, prob_vec &probs) break; } } - probs_pointer[pmeasure_idx] += std::norm(m_state[i]); + +#pragma omp critical + { + probs[pmeasure_idx] += std::norm(m_state[i]); + } + } return qErrorNone; @@ -549,6 +551,36 @@ QError CPUImplQPU::_CR(size_t qn_0, size_t qn_1, QStat &matrix, bool is_dagger) return qErrorNone; } +QError CPUImplQPU::_CP(size_t qn_0, size_t qn_1, QStat &matrix, bool is_dagger) +{ + int64_t size = 1ll << (m_qubit_num - 2); + int64_t offset0 = 1ll << qn_0; + int64_t offset1 = 1ll << qn_1; + if (is_dagger) + { + matrix[15] = { matrix[15].real(), -matrix[15].imag() }; + } + + if (size > m_threshold) + { +#pragma omp parallel for + for (int64_t i = 0; i < size; i++) + { + int64_t real00_idx = _insert(i, qn_1, qn_0); + m_state[real00_idx | offset0 | offset1] *= matrix[15]; + } + } + else + { + for (int64_t i = 0; i < size; i++) + { + int64_t real00_idx = _insert(i, qn_1, qn_0); + m_state[real00_idx | offset0 | offset1] *= matrix[15]; + } + } + return qErrorNone; +} + QError CPUImplQPU::_SWAP(size_t qn_0, size_t qn_1) { int64_t size = 1ll << (m_qubit_num - 2); @@ -722,6 +754,36 @@ QError CPUImplQPU::_U1(size_t qn, QStat &matrix, bool is_dagger) return qErrorNone; } +QError CPUImplQPU::_P(size_t qn, QStat &matrix, bool is_dagger) +{ + int64_t size = 1ll << (m_qubit_num - 1); + int64_t offset = 1ll << qn; + if (is_dagger) + { + matrix[3] = qcomplex_t(matrix[3].real(), -matrix[3].imag()); + } + + if (size > m_threshold) + { +#pragma omp parallel for + for (int64_t i = 0; i < size; i++) + { + int64_t real00_idx = _insert(i, qn); + int64_t real01_idx = real00_idx | offset; + m_state[real01_idx] *= matrix[3]; + } + } + else + { + for (int64_t i = 0; i < size; i++) + { + int64_t real00_idx = _insert(i, qn); + int64_t real01_idx = real00_idx | offset; + m_state[real01_idx] *= matrix[3]; + } + } + return qErrorNone; +} QError CPUImplQPU::_X(size_t qn, Qnum &controls) { @@ -1073,6 +1135,45 @@ QError CPUImplQPU::_CR(size_t qn_0, size_t qn_1, QStat &matrix, bool is_dagger, return qErrorNone; } +QError CPUImplQPU::_CP(size_t qn_0, size_t qn_1, QStat &matrix, bool is_dagger, Qnum &controls) +{ + int64_t size = 1ll << (m_qubit_num - 2); + int64_t offset0 = 1ll << qn_0; + int64_t offset1 = 1ll << qn_1; + int64_t mask = 0; + for_each(controls.begin(), controls.end() - 2, [&](size_t &q) { + mask |= 1ll << q; + }); + + if (is_dagger) + { + matrix[15] = { matrix[15].real(), -matrix[15].imag() }; + } + + if (size > m_threshold) + { +#pragma omp parallel for + for (int64_t i = 0; i < size; i++) + { + int64_t real00_idx = _insert(i, qn_1, qn_0); + if (mask != (mask & real00_idx)) + continue; + m_state[real00_idx | offset0 | offset1] *= matrix[15]; + } + } + else + { + for (int64_t i = 0; i < size; i++) + { + int64_t real00_idx = _insert(i, qn_1, qn_0); + if (mask != (mask & real00_idx)) + continue; + m_state[real00_idx | offset0 | offset1] *= matrix[15]; + } + } + return qErrorNone; +} + QError CPUImplQPU::_SWAP(size_t qn_0, size_t qn_1, Qnum &controls) { int64_t size = 1ll << (m_qubit_num - 2); @@ -1299,6 +1400,45 @@ QError CPUImplQPU::_U1(size_t qn, QStat &matrix, bool is_dagger, Qnum &controls) return qErrorNone; } +QError CPUImplQPU::_P(size_t qn, QStat &matrix, bool is_dagger, Qnum &controls) +{ + int64_t size = 1ll << (m_qubit_num - 1); + int64_t offset = 1ll << qn; + int64_t mask = 0; + for_each(controls.begin(), controls.end() - 1, [&](size_t &q) { + mask |= 1ll << q; + }); + + if (is_dagger) + { + matrix[3] = qcomplex_t(matrix[3].real(), -matrix[3].imag()); + } + + if (size > m_threshold) + { +#pragma omp parallel for + for (int64_t i = 0; i < size; i++) + { + int64_t real00_idx = _insert(i, qn); + if (mask != (mask & real00_idx)) + continue; + int64_t real01_idx = real00_idx | offset; + m_state[real01_idx] *= matrix[3]; + } + } + else + { + for (int64_t i = 0; i < size; i++) + { + int64_t real00_idx = _insert(i, qn); + if (mask != (mask & real00_idx)) + continue; + int64_t real01_idx = real00_idx | offset; + m_state[real01_idx] *= matrix[3]; + } + } + return qErrorNone; +} QError CPUImplQPU::_single_qubit_normal_unitary(size_t qn, QStat &matrix, bool is_dagger) { @@ -1578,6 +1718,9 @@ unitarySingleQubitGate(size_t qn, case GateType::U1_GATE: _U1(qn, matrix, is_dagger); break; + case GateType::P_GATE: + _P(qn, matrix, is_dagger); + break; case GateType::RZ_GATE: case GateType::Z_HALF_PI: _RZ(qn, matrix, is_dagger); @@ -1631,6 +1774,9 @@ controlunitarySingleQubitGate(size_t qn, case GateType::U1_GATE: _U1(qn, matrix, is_dagger, controls); break; + case GateType::P_GATE: + _P(qn, matrix, is_dagger, controls); + break; case GateType::RZ_GATE: case GateType::Z_HALF_PI: _RZ(qn, matrix, is_dagger, controls); @@ -1673,6 +1819,9 @@ unitaryDoubleQubitGate(size_t qn_0, case GateType::CPHASE_GATE: _CR(qn_0, qn_1, matrix, is_dagger); break; + case GateType::CP_GATE: + _CP(qn_0, qn_1, matrix, is_dagger); + break; case GateType::SWAP_GATE: _SWAP(qn_0, qn_1); break; @@ -1714,6 +1863,9 @@ controlunitaryDoubleQubitGate(size_t qn_0, case GateType::CPHASE_GATE: _CR(qn_0, qn_1, matrix, is_dagger, controls); break; + case GateType::CP_GATE: + _CP(qn_0, qn_1, matrix, is_dagger, controls); + break; case GateType::SWAP_GATE: _SWAP(qn_0, qn_1, controls); break; @@ -1767,7 +1919,11 @@ int CPUImplQPU::_omp_thread_num(size_t size) { if (size > m_threshold) { +#ifdef USE_OPENMP return omp_get_max_threads(); +#else + return 1; +#endif } else { diff --git a/include/Core/Core.h b/include/Core/Core.h index 7f9eed0f..5f5adbca 100644 --- a/include/Core/Core.h +++ b/include/Core/Core.h @@ -328,14 +328,7 @@ QuantumMachine *initQuantumMachine(QMachineType type=CPU); */ void destroyQuantumMachine(QuantumMachine * qvm); -/** -* @brief Measure All ClassicalCondition -* @ingroup Core -* @param[in] QVec& qubits vector -* @param[in] std::vector Cbits vector -* @return QPanda::QProg Quantum program -*/ -QPanda::QProg MeasureAll(QVec, std::vector); + extern QProg transformOriginIRToQProg(std::string filePath, QuantumMachine* qm, QVec &qv, std::vector &cv); diff --git a/include/Core/QuantumCircuit/QGate.h b/include/Core/QuantumCircuit/QGate.h index 8da6c037..28109798 100644 --- a/include/Core/QuantumCircuit/QGate.h +++ b/include/Core/QuantumCircuit/QGate.h @@ -487,6 +487,42 @@ QGate U1(int qaddr, double angle); */ QCircuit U1(const std::vector& qaddrs, double angle); +/** +* @brief Construct a new quantum P gate +* @param[in] Qubit* target qubit +* @param[in] double angle +* @return QPanda::QGate quantum gate +* @ingroup QuantumCircuit +*/ +QGate P(Qubit*, double angle); + +/** +* @brief Construct qubits.size() new P gate +* @param[in] const QVec& qubits target qubits vector +* @return QPanda::QCircuit quantum circuit +* @ingroup QuantumCircuit +*/ +QCircuit P(const QVec& qubites, double angle); + +/** +* @brief Construct a new quantum P gate +* @param[in] int qaddr target qubit phy addr +* @param[in] double angle +* @return QPanda::QGate quantum gate +* @ingroup QuantumCircuit +*/ +QGate P(int qaddr, double angle); + +/** +* @brief Construct qaddrs.size() new quantum P gate +* @param[in] int qaddr target qubit phy addr +* @param[in] double angle +* @return QPanda::QGate quantum gate +* @ingroup QuantumCircuit +*/ +QCircuit P(const std::vector& qaddrs, double angle); + + /** * @brief Construct a new quantum U2 gate * @param[in] Qubit* target qubit @@ -747,6 +783,7 @@ QGate Z1(int qaddr); */ QCircuit Z1(const std::vector& qaddrs); + /** * @brief Construct a new quantum RZ gate * @param[in] Qubit* target qubit @@ -1311,6 +1348,47 @@ QGate CR(int control_qaddr, int target_qaddr, double theta); */ QCircuit CR(const std::vector& control_qaddrs, const std::vector& target_qaddrs, double theta); +/** +* @brief Construct a new quantum CP gate +* @param[in] Qubit* control qubit +* @param[in] Qubit* targit qubit +* @param[in] double theta +* @return QPanda::QGate quantum gate +* @ingroup QuantumCircuit +*/ +QGate CP(Qubit * control_qubit, Qubit * targit_qubit, double theta); + +/** +* @brief Construct control_qubits.size() new quantum CP gate +* @param[in] Qubit* control qubit +* @param[in] Qubit* targit qubit +* @param[in] double theta +* @return QPanda::QGate quantum gate +* @ingroup QuantumCircuit +*/ +QCircuit CP(const QVec& control_qubits, const QVec& targit_qubits, double theta); + +/** +* @brief Construct a new quantum CP gate +* @param[in] int qaddr control qubit phy addr +* @param[in] int qaddr target qubit phy addr +* @param[in] double theta +* @return QPanda::QGate quantum gate +* @ingroup QuantumCircuit +*/ +QGate CP(int control_qaddr, int target_qaddr, double theta); + +/** +* @brief Construct control_qaddrs.size() new quantum CP gate +* @param[in] int qaddr control qubit phy addr +* @param[in] int qaddr target qubit phy addr +* @param[in] double theta +* @return QPanda::QGate quantum gate +* @ingroup QuantumCircuit +*/ +QCircuit CP(const std::vector& control_qaddrs, const std::vector& target_qaddrs, double theta); + + /** * @brief Construct a new quantum SqiSWAP gate * @param[in] Qubit* control qubit diff --git a/include/Core/QuantumCircuit/QGlobalVariable.h b/include/Core/QuantumCircuit/QGlobalVariable.h index 79e1ffd3..281b2f4f 100644 --- a/include/Core/QuantumCircuit/QGlobalVariable.h +++ b/include/Core/QuantumCircuit/QGlobalVariable.h @@ -51,6 +51,7 @@ enum GateType { X_HALF_PI,/**< Quantum x half gate */ Y_HALF_PI,/**< Quantum y half gate */ Z_HALF_PI,/**< Quantum z half gate */ + P_GATE,/***/ HADAMARD_GATE,/**< Quantum hadamard gate */ T_GATE,/**< Quantum t gate */ S_GATE,/**< Quantum s gate */ @@ -65,6 +66,7 @@ enum GateType { CU_GATE,/**< Quantum control-u gate */ CNOT_GATE,/**< Quantum control-not gate */ CZ_GATE,/**< Quantum control-z gate */ + CP_GATE,/***/ CPHASE_GATE,/**< Quantum control-rotation gate */ ISWAP_THETA_GATE,/**< Quantum iswap-theta gate */ ISWAP_GATE,/**< Quantum iswap gate */ diff --git a/include/Core/QuantumCircuit/QuantumGate.h b/include/Core/QuantumCircuit/QuantumGate.h index c594e59f..57d42867 100644 --- a/include/Core/QuantumCircuit/QuantumGate.h +++ b/include/Core/QuantumCircuit/QuantumGate.h @@ -583,6 +583,29 @@ namespace QGATE_SPACE } }; + class P :public U4, + public AbstractSingleAngleParameter, + public DynamicCreator, + public DynamicCreator + { + public: + P(QuantumGate * gate_old) :U4(gate_old) + { + if (gate_old->getGateType() != GateType::U1_GATE) + { + QCERR("Parameter qgate_old error"); + throw std::invalid_argument("Parameter qgate_old error"); + } + gate_type = gate_old->getGateType(); + }; + P(double); + inline double getParameter() const + { + return this->beta; + } + }; + + class U2 :public U4, public DynamicCreator, public DynamicCreator @@ -817,6 +840,29 @@ namespace QGATE_SPACE CZ(); }; + class CP :public CU, + public DynamicCreator, + public DynamicCreator + { + public: + CP(QuantumGate * gate_old) :CU(gate_old) + { + if (gate_old->getGateType() != GateType::CP_GATE) + { + QCERR("Parameter qgate_old error"); + throw std::invalid_argument("Parameter qgate_old error"); + } + gate_type = gate_old->getGateType(); + } + + CP(double); + inline double getParameter() const + { + return this->beta; + } + + }; + class ISWAPTheta : public QDoubleGate, public AbstractSingleAngleParameter, public DynamicCreator, diff --git a/include/Core/QuantumCircuit/QuantumMeasure.h b/include/Core/QuantumCircuit/QuantumMeasure.h index f838c57c..ebd6cd46 100644 --- a/include/Core/QuantumCircuit/QuantumMeasure.h +++ b/include/Core/QuantumCircuit/QuantumMeasure.h @@ -22,7 +22,8 @@ limitations under the License. #include "Core/QuantumCircuit/ClassicalConditionInterface.h" QPANDA_BEGIN - +class QVec; +class QProg; /** * @class AbstractQuantumMeasure * @brief Quantum Measure basic abstract class @@ -167,6 +168,17 @@ QMeasure Measure(Qubit * , ClassicalCondition ); */ QMeasure Measure(int, int); +/** +* @brief Measure All ClassicalCondition +* @ingroup Core +* @param[in] QVec& qubits vector +* @param[in] std::vector Cbits vector +* @return QPanda::QProg Quantum program +*/ +QProg MeasureAll(const QVec&, const std::vector&); + +QProg MeasureAll(const std::vector&, const std::vector&); + QPANDA_END #endif // !_QUANTUM_MEASURE_H diff --git a/include/Core/Utilities/Tools/QuantumStateTomography.h b/include/Core/Utilities/Tools/QuantumStateTomography.h index 492caad2..55af3f5c 100644 --- a/include/Core/Utilities/Tools/QuantumStateTomography.h +++ b/include/Core/Utilities/Tools/QuantumStateTomography.h @@ -3,6 +3,7 @@ #include "Core/QuantumMachine/OriginQuantumMachine.h" #include "Core/QuantumMachine/QuantumMachineInterface.h" +#include "Core/QuantumCircuit/QNodeDeepCopy.h" QPANDA_BEGIN diff --git a/include/Core/VirtualQuantumProcessor/CPUImplQPU.h b/include/Core/VirtualQuantumProcessor/CPUImplQPU.h index d416634f..ac14d99b 100644 --- a/include/Core/VirtualQuantumProcessor/CPUImplQPU.h +++ b/include/Core/VirtualQuantumProcessor/CPUImplQPU.h @@ -139,6 +139,13 @@ class CPUImplQPU : public QPUImpl return qErrorNone; } + QError P_GATE(size_t qn, double theta, bool is_dagger, double error_rate) + { + QStat matrix = { 1, 0, 0, qcomplex_t(cos(theta),sin(theta)) }; + _U1(qn, matrix, is_dagger); + return qErrorNone; + } + template QError single_angle_gate(size_t qn, double theta, bool is_dagger, double error_rate) @@ -296,6 +303,28 @@ class CPUImplQPU : public QPUImpl return qErrorNone; } + inline QError CP(size_t qn_0, size_t qn_1, + double theta, bool isConjugate, double error_rate) + { + QStat matrix = { 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, qcomplex_t(std::cos(theta), std::sin(theta)) }; + _CP(qn_0, qn_1, matrix, isConjugate); + return qErrorNone; + } + + inline QError CP(size_t qn_0, size_t qn_1, Qnum& vControlBit, + double theta, bool isConjugate, double error_rate) + { + QStat matrix = { 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, qcomplex_t(std::cos(theta), std::sin(theta)) }; + _CP(qn_0, qn_1, matrix, isConjugate, vControlBit); + return qErrorNone; + } + inline QError CZ(size_t qn_0, size_t qn_1, bool isConjugate, double error_rate) { CR(qn_0, qn_1, PI, isConjugate, error_rate); @@ -372,12 +401,14 @@ class CPUImplQPU : public QPUImpl QError _Z(size_t qn); QError _S(size_t qn, bool is_dagger); QError _U1(size_t qn, QStat &matrix, bool is_dagger); + QError _P(size_t qn, QStat &matrix, bool is_dagger); QError _RZ(size_t qn, QStat &matrix, bool is_dagger); QError _H(size_t qn, QStat &matrix); QError _CNOT(size_t qn_0, size_t qn_1); QError _CZ(size_t qn_0, size_t qn_1); QError _CR(size_t qn_0, size_t qn_1, QStat &matrix, bool is_dagger); + QError _CP(size_t qn_0, size_t qn_1, QStat &matrix, bool is_dagger); QError _SWAP(size_t qn_0, size_t qn_1); QError _iSWAP(size_t qn_0, size_t qn_1, QStat &matrix, bool is_dagger); QError _iSWAP_theta(size_t qn_0, size_t qn_1, QStat &matrix, bool is_dagger); @@ -388,12 +419,14 @@ class CPUImplQPU : public QPUImpl QError _Z(size_t qn, Qnum &controls); QError _S(size_t qn, bool is_dagger, Qnum &controls); QError _U1(size_t qn, QStat &matrix, bool is_dagger, Qnum &controls); + QError _P(size_t qn, QStat &matrix, bool is_dagger, Qnum &controls); QError _RZ(size_t qn, QStat &matrix, bool is_dagger, Qnum &controls); QError _H(size_t qn, QStat &matrix, Qnum &controls); QError _CNOT(size_t qn_0, size_t qn_1, Qnum &controls); QError _CZ(size_t qn_0, size_t qn_1, Qnum &controls); QError _CR(size_t qn_0, size_t qn_1, QStat &matrix, bool is_dagger, Qnum &controls); + QError _CP(size_t qn_0, size_t qn_1, QStat &matrix, bool is_dagger, Qnum &controls); QError _SWAP(size_t qn_0, size_t qn_1, Qnum &controls); QError _iSWAP(size_t qn_0, size_t qn_1, QStat &matrix, bool is_dagger, Qnum &controls); QError _iSWAP_theta(size_t qn_0, size_t qn_1, QStat &matrix, bool is_dagger, Qnum &controls); diff --git a/pyQPandaCpp/pyQPanda.Core/pyqpanda.core.cpp b/pyQPandaCpp/pyQPanda.Core/pyqpanda.core.cpp index ae700771..8db697f6 100644 --- a/pyQPandaCpp/pyQPanda.Core/pyqpanda.core.cpp +++ b/pyQPandaCpp/pyQPanda.Core/pyqpanda.core.cpp @@ -36,29 +36,29 @@ void init_extension_funtion(py::module & m); PYBIND11_MODULE(pyQPanda, m) { - init_quantum_machine(m); - init_core_class(m); - init_variational(m); - init_qalg(m); - init_components(m); + init_quantum_machine(m); + init_core_class(m); + init_variational(m); + init_qalg(m); + init_components(m); init_QAlg_class(m); - init_extension_class(m); - init_extension_funtion(m); + init_extension_class(m); + init_extension_funtion(m); - m.doc() = ""; + m.doc() = ""; - m.def("init", - &init, - "to init the environment. Use this at the beginning" - ); + m.def("init", + &init, + "to init the environment. Use this at the beginning" + ); - m.def("init_quantum_machine", &initQuantumMachine, - "Create and initialize a quantum machine", - py::return_value_policy::reference); + m.def("init_quantum_machine", &initQuantumMachine, + "Create and initialize a quantum machine", + py::return_value_policy::reference); - m.def("get_qstate", &getQState, - "get prog qstate", - py::return_value_policy::automatic); + m.def("get_qstate", &getQState, + "get prog qstate", + py::return_value_policy::automatic); #define DEFINE_DESTROY(type)\ m.def("destroy_quantum_machine", [] (type *machine){\ @@ -66,188 +66,209 @@ PYBIND11_MODULE(pyQPanda, m) },\ "destroy a quantum machine", py::return_value_policy::automatic) - DEFINE_DESTROY(CPUQVM); - DEFINE_DESTROY(CPUSingleThreadQVM); - DEFINE_DESTROY(GPUQVM); - DEFINE_DESTROY(NoiseQVM); - - m.def("finalize", []() { finalize(); }, - "to finalize the environment. Use this at the end", - py::return_value_policy::reference - ); - - m.def("qAlloc", []() {return qAlloc(); }, - "Allocate a qubit", - py::return_value_policy::reference - ); - - m.def("qAlloc", [](size_t size) {return qAlloc(size); }, - "Allocate a qubits", - py::return_value_policy::reference - ); - - - m.def("qAlloc_many", [](size_t size) { - std::vector temp = qAllocMany(size); - return temp; - }, - "Allocate several qubits", - py::return_value_policy::reference - ); - - m.def("cAlloc", []() {return cAlloc(); }, - "Allocate a CBit", - py::return_value_policy::reference - ); - - /* add */ - m.def("cAlloc", [](size_t size) {return cAlloc(size); }, - "Allocate a CBit", - py::return_value_policy::reference - ); - - m.def("cAlloc_many", [](size_t size) {return cAllocMany(size); }, - "Allocate several CBits", - py::return_value_policy::reference - ); - - m.def("cFree", &cFree, "Free a CBit"); - - m.def("cFree_all", &cFreeAll, "Free several CBit"); - - m.def("apply_QGate", [](const QVec &qlist, const std::function &fun)->QCircuit{ - QCircuit cir; - for (auto &q : qlist) - { - cir << fun(q); - } - return cir; - }, - "Apply QGate to qubits", - py::return_value_policy::reference - ); - - m.def("apply_QGate", [](const std::vector &qlist_addr, const std::function &fun)->QCircuit { - QCircuit cir; - for (auto &q : qlist_addr) - { - cir << fun(q); - } - return cir; - }, - "Apply QGate to qlist_addr", - py::return_value_policy::reference - ); - - m.def("getstat", &getstat, - "get the status(ptr) of the quantum machine"); - - /* will delete */ - m.def("getAllocateQubitNum", &getAllocateQubitNum, - "getAllocateQubitNum"); - - m.def("getAllocateCMem", &getAllocateCMem, "getAllocateCMem"); - - m.def("CreateEmptyQProg", &CreateEmptyQProg, - "Create an empty QProg Container", - py::return_value_policy::automatic - ); - - m.def("CreateWhileProg", CreateWhileProg, - "Classical_condition"_a, "true_node"_a, - "Create a WhileProg", - py::return_value_policy::automatic - ); - - m.def("CreateIfProg", [](ClassicalCondition m, QProg &qn) - {return CreateIfProg(m, qn); }, - "Classical_condition"_a, "true_node"_a, - "Create a IfProg", - py::return_value_policy::automatic - ); - - m.def("CreateIfProg", [](ClassicalCondition&m, QProg &qn1, QProg &qn2) - {return CreateIfProg(m, qn1, qn2); }, - "Classical_condition"_a, "true_node"_a, "false_node"_a, - "Create a IfProg", - py::return_value_policy::automatic - ); - - m.def("CreateEmptyCircuit", &CreateEmptyCircuit, - "Create an empty QCircuit Container", - py::return_value_policy::automatic - ); - - /* new interface */ - m.def("get_allocate_qubit_num", &getAllocateQubitNum, - "get allocate qubit num", - py::return_value_policy::automatic); - m.def("get_allocate_cmem_num", &getAllocateCMem, - "get allocate cmemnum", - py::return_value_policy::automatic); - - m.def("create_empty_qprog", &createEmptyQProg, - "Create an empty QProg Container", - py::return_value_policy::automatic - ); - - m.def("create_while_prog", &createWhileProg, - "Classical_condition"_a, "true_branch"_a, - "Create a WhileProg", - py::return_value_policy::automatic - ); - - m.def("create_if_prog", [](ClassicalCondition m, QProg &true_branch) - {return createIfProg(m, true_branch); }, - "Classical_condition"_a, "true_branch"_a, - "Create a IfProg", - py::return_value_policy::automatic - ); - - m.def("create_if_prog", [](ClassicalCondition&m, QProg &true_branch, QProg &false_branch) - {return createIfProg(m, true_branch, false_branch); }, - "Classical_condition"_a, "true_branch"_a, "false_branch"_a, - "Create a IfProg", - py::return_value_policy::automatic - ); - - m.def("create_empty_circuit", &createEmptyCircuit, - "Create an empty QCircuit Container", - py::return_value_policy::automatic - ); - - - m.def("directly_run", &directlyRun, "directly run"); - - m.def("quick_measure", &quickMeasure, "qubit_list"_a, "shots"_a, "quick measure"); - - m.def("Measure", [](Qubit* qbit, ClassicalCondition cbit) - {return Measure(qbit, cbit); }, - "qubit"_a, "cbit"_a, - "Create a Measure operation", - py::return_value_policy::automatic - ); - - m.def("Measure", [](int qbit_addr, int cbit_addr) - { return Measure(qbit_addr, cbit_addr); }, - "qubit addr"_a, "cbit addr"_a, - "Create a Measure operation", - py::return_value_policy::automatic - ); - - m.def("measure_all", &MeasureAll, "qubit_list"_a, "cbit_list"_a, - "Create a Measure operation", - py::return_value_policy::automatic - ); - - m.def("H", [](Qubit* qbit){ return H(qbit); }, - "qubit"_a, - "Create a H gate", - py::return_value_policy::automatic - ); + DEFINE_DESTROY(CPUQVM); + DEFINE_DESTROY(CPUSingleThreadQVM); + DEFINE_DESTROY(GPUQVM); + DEFINE_DESTROY(NoiseQVM); + + m.def("finalize", []() { finalize(); }, + "to finalize the environment. Use this at the end", + py::return_value_policy::reference + ); + + m.def("qAlloc", []() {return qAlloc(); }, + "Allocate a qubit", + py::return_value_policy::reference + ); + + m.def("qAlloc", [](size_t size) {return qAlloc(size); }, + "Allocate a qubits", + py::return_value_policy::reference + ); + + + m.def("qAlloc_many", [](size_t size) { + std::vector temp = qAllocMany(size); + return temp; + }, + "Allocate several qubits", + py::return_value_policy::reference + ); + + m.def("cAlloc", []() {return cAlloc(); }, + "Allocate a CBit", + py::return_value_policy::reference + ); + + /* add */ + m.def("cAlloc", [](size_t size) {return cAlloc(size); }, + "Allocate a CBit", + py::return_value_policy::reference + ); + + m.def("cAlloc_many", [](size_t size) {return cAllocMany(size); }, + "Allocate several CBits", + py::return_value_policy::reference + ); + + m.def("cFree", &cFree, "Free a CBit"); + + m.def("cFree_all", &cFreeAll, "Free several CBit"); + + m.def("apply_QGate", [](const QVec &qlist, const std::function &fun)->QCircuit { + QCircuit cir; + for (auto &q : qlist) + { + cir << fun(q); + } + return cir; + }, + "Apply QGate to qubits", + py::return_value_policy::reference + ); + + m.def("apply_QGate", [](const std::vector &qlist_addr, const std::function &fun)->QCircuit { + QCircuit cir; + for (auto &q : qlist_addr) + { + cir << fun(q); + } + return cir; + }, + "Apply QGate to qlist_addr", + py::return_value_policy::reference + ); + + m.def("getstat", &getstat, + "get the status(ptr) of the quantum machine"); + + /* will delete */ + m.def("getAllocateQubitNum", &getAllocateQubitNum, + "getAllocateQubitNum"); + + m.def("getAllocateCMem", &getAllocateCMem, "getAllocateCMem"); + + m.def("CreateEmptyQProg", &CreateEmptyQProg, + "Create an empty QProg Container", + py::return_value_policy::automatic + ); + + m.def("CreateWhileProg", CreateWhileProg, + "Classical_condition"_a, "true_node"_a, + "Create a WhileProg", + py::return_value_policy::automatic + ); + + m.def("CreateIfProg", [](ClassicalCondition m, QProg &qn) + {return CreateIfProg(m, qn); }, + "Classical_condition"_a, "true_node"_a, + "Create a IfProg", + py::return_value_policy::automatic + ); + + m.def("CreateIfProg", [](ClassicalCondition&m, QProg &qn1, QProg &qn2) + {return CreateIfProg(m, qn1, qn2); }, + "Classical_condition"_a, "true_node"_a, "false_node"_a, + "Create a IfProg", + py::return_value_policy::automatic + ); + + m.def("CreateEmptyCircuit", &CreateEmptyCircuit, + "Create an empty QCircuit Container", + py::return_value_policy::automatic + ); + + /* new interface */ + m.def("get_allocate_qubit_num", &getAllocateQubitNum, + "get allocate qubit num", + py::return_value_policy::automatic); + m.def("get_allocate_cmem_num", &getAllocateCMem, + "get allocate cmemnum", + py::return_value_policy::automatic); + + m.def("create_empty_qprog", &createEmptyQProg, + "Create an empty QProg Container", + py::return_value_policy::automatic + ); + + m.def("create_while_prog", &createWhileProg, + "Classical_condition"_a, "true_branch"_a, + "Create a WhileProg", + py::return_value_policy::automatic + ); + + m.def("create_if_prog", [](ClassicalCondition m, QProg &true_branch) + {return createIfProg(m, true_branch); }, + "Classical_condition"_a, "true_branch"_a, + "Create a IfProg", + py::return_value_policy::automatic + ); + + m.def("create_if_prog", [](ClassicalCondition&m, QProg &true_branch, QProg &false_branch) + {return createIfProg(m, true_branch, false_branch); }, + "Classical_condition"_a, "true_branch"_a, "false_branch"_a, + "Create a IfProg", + py::return_value_policy::automatic + ); + + m.def("create_empty_circuit", &createEmptyCircuit, + "Create an empty QCircuit Container", + py::return_value_policy::automatic + ); + + + m.def("directly_run", &directlyRun, "directly run"); + + m.def("quick_measure", &quickMeasure, "qubit_list"_a, "shots"_a, "quick measure"); + + m.def("Measure", [](Qubit* qbit, ClassicalCondition cbit) + {return Measure(qbit, cbit); }, + "qubit"_a, "cbit"_a, + "Create a Measure operation", + py::return_value_policy::automatic + ); + + m.def("Measure", [](int qbit_addr, int cbit_addr) + { return Measure(qbit_addr, cbit_addr); }, + "qubit addr"_a, "cbit addr"_a, + "Create a Measure operation", + py::return_value_policy::automatic + ); + + m.def("measure_all", [](const std::vector& iQubit, const std::vector& cCBit) + { return MeasureAll(iQubit, cCBit); }, + "qubit_list"_a, "cbit_list"_a, + "Create a Measure operation", + py::return_value_policy::automatic + ); + + m.def("measure_all", [](const QVec& vQubit, const std::vector& vCBit) + { return MeasureAll(vQubit, vCBit); }, + "qubit_list"_a, "cbit_list"_a, + "Create a Measure operation", + py::return_value_policy::automatic + ); + + m.def("H", [](Qubit* qbit) { return H(qbit); }, + "qubit"_a, + "Create a H gate", + py::return_value_policy::automatic + ); + + m.def("H", [](const QVec& qbits) {return H(qbits); }, + "qubit"_a, + "Create qbits.size() gate", + py::return_value_policy::automatic + ); m.def("H", [](int qbit_addr) { return H(qbit_addr); }, - "qubit phy addr"_a, + "qubit phy addr"_a, + "Create a H gate", + py::return_value_policy::automatic + ); + + m.def("H", [](const std::vector& qbit_addrs) { return H(qbit_addrs); }, + "qubit phy addr"_a, "Create a H gate", py::return_value_policy::automatic ); @@ -270,56 +291,93 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic ); + + m.def("T", [](const QVec& qbits) { return H(qbits); }, + "qubit"_a, + "Create a T gate", + py::return_value_policy::automatic + ); + m.def("T", [](int qbit_addr) { return T(qbit_addr); }, "qubit phy addr"_a, "Create a T gate", py::return_value_policy::automatic ); - m.def("S", [](Qubit* qbit) { return T(qbit); }, + m.def("T", [](const std::vector& qbit_addrs) { return T(qbit_addrs); }, + "qubit phy addr"_a, + "Create a T gate", + py::return_value_policy::automatic + ); + + m.def("S", [](Qubit* qbit) { return S(qbit); }, + "qubit"_a, + "Create a S gate", + py::return_value_policy::automatic + ); + + m.def("S", [](const QVec& qbits) { return S(qbits); }, "qubit"_a, "Create a S gate", py::return_value_policy::automatic ); + m.def("S", [](int qbit_addr) { return T(qbit_addr); }, "qubit phy addr"_a, "Create a S gate", py::return_value_policy::automatic ); + m.def("S", [](const std::vector& qbit_addr) { return S(qbit_addr); }, + "qubit phy addr"_a, + "Create a S gate", + py::return_value_policy::automatic + ); + m.def("I", [](Qubit* qbit) { return I(qbit); }, "qubit"_a, - "Create an I gate", + "Create an I gate", + py::return_value_policy::automatic + ); + + m.def("I", [](const QVec& qbits) { return I(qbits); }, + "qubit"_a, + "Create an I gate", py::return_value_policy::automatic ); m.def("I", [](int qbit_addr) { return I(qbit_addr); }, "qubit phy addr"_a, - "Create an I gate", + "Create an I gate", py::return_value_policy::automatic ); + m.def("I", [](const std::vector& qbit_addrs) { return I(qbit_addrs); }, + "qubit phy addr"_a, + "Create an I gate", + py::return_value_policy::automatic + ); - m.def("BARRIER", [](Qubit* qubit) - {return BARRIER(qubit); }, - "qubit"_a, - "Create an BARRIER gate", - py::return_value_policy::automatic - ); + m.def("BARRIER", [](Qubit* qubit) + {return BARRIER(qubit); }, + "qubit"_a, + "Create an BARRIER gate", + py::return_value_policy::automatic + ); m.def("BARRIER", [](int qbit_addr) { return BARRIER(qbit_addr); }, "qubit phy addr"_a, - "Create an BARRIER gate", + "Create an BARRIER gate", py::return_value_policy::automatic ); - m.def("BARRIER", [](QVec qubits) - {return BARRIER(qubits); }, - "qubit list"_a, - "Create an BARRIER gate", - py::return_value_policy::automatic - ); + m.def("BARRIER", [](QVec qubits) + {return BARRIER(qubits); }, + "qubit list"_a, + "Create an BARRIER gate", + py::return_value_policy::automatic + ); m.def("BARRIER", [](std::vector qbit_addrs) { return BARRIER(qbit_addrs); }, "qubit phy addr list"_a, @@ -329,25 +387,49 @@ PYBIND11_MODULE(pyQPanda, m) m.def("X", [](Qubit* qbit) { return X(qbit); }, "qubit"_a, - "Create an X gate", + "Create an X gate", + py::return_value_policy::automatic + ); + + m.def("X", [](const QVec& qbits) { return X(qbits); }, + "qubit"_a, + "Create an X gate", py::return_value_policy::automatic ); m.def("X", [](int qbit_addr) { return X(qbit_addr); }, "qubit phy addr"_a, - "Create an X gate", + "Create an X gate", + py::return_value_policy::automatic + ); + + m.def("X", [](const std::vector& qbit_addrs) { return X(qbit_addrs); }, + "qubit phy addr"_a, + "Create an X gate", py::return_value_policy::automatic ); m.def("Y", [](Qubit* qbit) { return Y(qbit); }, "qubit"_a, - "Create a Y gate", + "Create a Y gate", + py::return_value_policy::automatic + ); + + m.def("Y", [](const QVec& qbits) { return Y(qbits); }, + "qubit"_a, + "Create a Y gate", py::return_value_policy::automatic ); m.def("Y", [](int qbit_addr) { return Y(qbit_addr); }, "qubit phy addr"_a, - "Create a Y gate", + "Create a Y gate", + py::return_value_policy::automatic + ); + + m.def("Y", [](const std::vector& qbit_addrs) { return Y(qbit_addrs); }, + "qubit phy addr"_a, + "Create a Y gate", py::return_value_policy::automatic ); @@ -357,51 +439,106 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic ); + m.def("Z", [](const QVec& qbits) { return Z(qbits); }, + "qubit"_a, + "Create a Z gate", + py::return_value_policy::automatic + ); + m.def("Z", [](int qbit_addr) { return Z(qbit_addr); }, "qubit phy addr"_a, "Create a Z gate", py::return_value_policy::automatic ); + m.def("Z", [](const std::vector& qbit_addrs) { return Z(qbit_addrs); }, + "qubit phy addr"_a, + "Create a Z gate", + py::return_value_policy::automatic + ); + m.def("X1", [](Qubit* qbit) { return X1(qbit); }, "qubit"_a, "Create a X1 gate", py::return_value_policy::automatic ); + m.def("X1", [](const QVec& qbits) { return X1(qbits); }, + "qubit"_a, + "Create a X1 gate", + py::return_value_policy::automatic + ); + m.def("X1", [](int qbit_addr) { return X1(qbit_addr); }, "qubit phy addr"_a, "Create a X1 gate", py::return_value_policy::automatic ); + m.def("X1", [](const std::vector& qbit_addrs) { return X1(qbit_addrs); }, + "qubit phy addr"_a, + "Create a X1 gate", + py::return_value_policy::automatic + ); + m.def("Y1", [](Qubit* qbit) { return Y1(qbit); }, "qubit"_a, "Create a Y1 gate", py::return_value_policy::automatic ); + m.def("Y1", [](const QVec& qbits) { return Y1(qbits); }, + "qubit"_a, + "Create a Y1 gate", + py::return_value_policy::automatic + ); + m.def("Y1", [](int qbit_addr) { return Y1(qbit_addr); }, "qubit phy addr"_a, "Create a Y1 gate", py::return_value_policy::automatic ); + m.def("Y1", [](const std::vector& qbit_addrs) { return Y1(qbit_addrs); }, + "qubit phy addr"_a, + "Create a Y1 gate", + py::return_value_policy::automatic + ); + m.def("Z1", [](Qubit* qbit) { return Z1(qbit); }, "qubit"_a, "Create a Z1 gate", py::return_value_policy::automatic ); + m.def("Z1", [](const QVec& qbits) { return Z1(qbits); }, + "qubit"_a, + "Create a Z1 gate", + py::return_value_policy::automatic + ); + m.def("Z1", [](int qbit_addr) { return Z1(qbit_addr); }, "qubit phy addr"_a, "Create a Y1 gate", py::return_value_policy::automatic ); + m.def("Z1", [](const std::vector& qbit_addrs) { return Z1(qbit_addrs); }, + "qubit phy addr"_a, + "Create a Y1 gate", + py::return_value_policy::automatic + ); + m.def("RX", [](Qubit* qbit, double angle) { return RX(qbit, angle); }, "qubit"_a, - "angle"_a, + "angle"_a, + "Create a RX gate", + py::return_value_policy::automatic + ); + + m.def("RX", [](const QVec& qbits, double angle) { return RX(qbits, angle); }, + "qubit"_a, + "angle"_a, "Create a RX gate", py::return_value_policy::automatic ); @@ -413,6 +550,13 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic ); + m.def("RX", [](const std::vector& qbit_addrs, double angle) { return RX(qbit_addrs, angle); }, + "qubit phy addr"_a, + "angle"_a, + "Create a RX gate", + py::return_value_policy::automatic + ); + m.def("RY", [](Qubit* qbit, double angle) { return RY(qbit, angle); }, "qubit"_a, "angle"_a, @@ -420,6 +564,13 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic ); + m.def("RY", [](const QVec& qbits, double angle) { return RY(qbits, angle); }, + "qubit"_a, + "angle"_a, + "Create a RY gate", + py::return_value_policy::automatic + ); + m.def("RY", [](int qbit_addr, double angle) { return RY(qbit_addr, angle); }, "qubit phy addr"_a, "angle"_a, @@ -427,6 +578,13 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic ); + m.def("RY", [](const std::vector& qbit_addrs, double angle) { return RY(qbit_addrs, angle); }, + "qubit phy addr"_a, + "angle"_a, + "Create a RY gate", + py::return_value_policy::automatic + ); + m.def("RZ", [](Qubit* qbit, double angle) { return RZ(qbit, angle); }, "qubit"_a, "angle"_a, @@ -434,72 +592,170 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic ); - m.def("RZ", [](int qbit_addr, double angle) { return RZ(qbit_addr, angle); }, - "qubit phy addr"_a, + m.def("RZ", [](const QVec& qbits, double angle) { return RZ(qbits, angle); }, + "qubit"_a, "angle"_a, "Create a RZ gate", py::return_value_policy::automatic ); - m.def("U1", [](Qubit* qbit, double angle) { return U1(qbit, angle); }, - "qubit"_a, + m.def("RZ", [](int qbit_addr, double angle) { return RZ(qbit_addr, angle); }, + "qubit phy addr"_a, "angle"_a, - "Create a U1 gate", + "Create a RZ gate", py::return_value_policy::automatic ); - m.def("U1", [](int qbit_addr, double angle) { return U1(qbit_addr, angle); }, + m.def("RZ", [](const std::vector& qbit_addrs, double angle) { return RZ(qbit_addrs, angle); }, "qubit phy addr"_a, "angle"_a, - "Create a U1 gate", + "Create a RZ gate", py::return_value_policy::automatic ); - m.def("U2", [](Qubit* qbit, double phi, double lambda) { return U2(qbit, phi, lambda); }, + m.def("P", [](Qubit* qbit, double angle) { return P(qbit, angle); }, "qubit"_a, - "phi"_a, "lambda"_a, "Create a U2 gate", + "angle"_a, + "Create a P gate", py::return_value_policy::automatic ); - m.def("U2", [](int qbit_addr, double phi, double lambda) { return U2(qbit_addr, phi, lambda); }, - "qubit phy addr"_a, - "phi"_a, "lambda"_a, "Create a U2 gate", + m.def("P", [](const QVec& qbits, double angle) { return P(qbits, angle); }, + "qubit"_a, + "angle"_a, + "Create a P gate", py::return_value_policy::automatic ); - m.def("U3", [](Qubit* qbit, double theta, double phi, double lambda) { return U3(qbit, theta, phi, lambda); }, - "qubit"_a, - "theta"_a, "phi"_a, "lambda"_a, "Create a U3 gate", + m.def("P", [](int qbit_addr, double angle) { return P(qbit_addr, angle); }, + "qubit phy addr"_a, + "angle"_a, + "Create a P gate", py::return_value_policy::automatic ); - m.def("U3", [](int qbit_addr, double theta, double phi, double lambda) { return U3(qbit_addr, theta, phi, lambda); }, + m.def("P", [](const std::vector& qbit_addrs, double angle) { return P(qbit_addrs, angle); }, "qubit phy addr"_a, - "theta"_a, "phi"_a, "lambda"_a, "Create a U3 gate", + "angle"_a, + "Create a P gate", py::return_value_policy::automatic ); - m.def("CNOT", [](Qubit* control_qubit, Qubit* target_qubit) { return CNOT(control_qubit, target_qubit); }, - "control_qubit"_a, "target_qubit"_a, - "Create a CNOT gate", + m.def("U1", [](Qubit* qbit, double angle) { return U1(qbit, angle); }, + "qubit"_a, + "angle"_a, + "Create a U1 gate", py::return_value_policy::automatic ); - m.def("CNOT", [](int control_qaddr, int target_qaddr) { return CNOT(control_qaddr, target_qaddr); }, - "control qubit addr"_a, "target qubit addr"_a, - "Create a CNOT gate", + m.def("U1", [](const QVec& qbits, double angle) { return U1(qbits, angle); }, + "qubit"_a, + "angle"_a, + "Create a U1 gate", py::return_value_policy::automatic ); - m.def("CZ", [](Qubit* control_qubit, Qubit* target_qubit) { return CZ(control_qubit, target_qubit); }, - "control_qubit"_a, "target_qubit"_a, - "Create a CZ gate", + m.def("U1", [](int qbit_addr, double angle) { return U1(qbit_addr, angle); }, + "qubit phy addr"_a, + "angle"_a, + "Create a U1 gate", py::return_value_policy::automatic ); - m.def("CZ", [](int control_qaddr, int target_qaddr) { return CZ(control_qaddr, target_qaddr); }, - "control qubit addr"_a, "target qubit addr"_a, - "Create a CZ gate", + m.def("U1", [](const std::vector& qbit_addrs, double angle) { return U1(qbit_addrs, angle); }, + "qubit phy addr"_a, + "angle"_a, + "Create a U1 gate", + py::return_value_policy::automatic + ); + + m.def("U2", [](Qubit* qbit, double phi, double lambda) { return U2(qbit, phi, lambda); }, + "qubit"_a, + "phi"_a, "lambda"_a, "Create a U2 gate", + py::return_value_policy::automatic + ); + + m.def("U2", [](const QVec& qbits, double phi, double lambda) { return U2(qbits, phi, lambda); }, + "qubit"_a, + "phi"_a, "lambda"_a, "Create a U2 gate", + py::return_value_policy::automatic + ); + + m.def("U2", [](const std::vector& qbit_addrs, double phi, double lambda) { return U2(qbit_addrs, phi, lambda); }, + "qubit phy addr"_a, + "phi"_a, "lambda"_a, "Create a U2 gate", + py::return_value_policy::automatic + ); + + m.def("U3", [](Qubit* qbit, double theta, double phi, double lambda) { return U3(qbit, theta, phi, lambda); }, + "qubit"_a, + "theta"_a, "phi"_a, "lambda"_a, "Create a U3 gate", + py::return_value_policy::automatic + ); + + m.def("U3", [](const QVec& qbits, double theta, double phi, double lambda) { return U3(qbits, theta, phi, lambda); }, + "qubit"_a, + "theta"_a, "phi"_a, "lambda"_a, "Create a U3 gate", + py::return_value_policy::automatic + ); + + m.def("U3", [](int qbit_addr, double theta, double phi, double lambda) { return U3(qbit_addr, theta, phi, lambda); }, + "qubit phy addr"_a, + "theta"_a, "phi"_a, "lambda"_a, "Create a U3 gate", + py::return_value_policy::automatic + ); + + m.def("U3", [](const std::vector& qbit_addrs, double theta, double phi, double lambda) { return U3(qbit_addrs, theta, phi, lambda); }, + "qubit phy addr"_a, + "theta"_a, "phi"_a, "lambda"_a, "Create a U3 gate", + py::return_value_policy::automatic + ); + + m.def("CNOT", [](Qubit* control_qubit, Qubit* target_qubit) { return CNOT(control_qubit, target_qubit); }, + "control_qubit"_a, "target_qubit"_a, + "Create a CNOT gate", + py::return_value_policy::automatic + ); + + m.def("CNOT", [](const QVec& control_qubits, const QVec& target_qubits) { return CNOT(control_qubits, target_qubits); }, + "control_qubit"_a, "target_qubit"_a, + "Create a CNOT gate", + py::return_value_policy::automatic + ); + + m.def("CNOT", [](int control_qaddr, int target_qaddr) { return CNOT(control_qaddr, target_qaddr); }, + "control qubit addr"_a, "target qubit addr"_a, + "Create a CNOT gate", + py::return_value_policy::automatic + ); + + m.def("CNOT", [](const std::vector& control_qaddrs, const std::vector& target_qaddrs) { return CNOT(control_qaddrs, target_qaddrs); }, + "control qubit addr"_a, "target qubit addr"_a, + "Create a CNOT gate", + py::return_value_policy::automatic + ); + + m.def("CZ", [](Qubit* control_qubit, Qubit* target_qubit) { return CZ(control_qubit, target_qubit); }, + "control_qubit"_a, "target_qubit"_a, + "Create a CZ gate", + py::return_value_policy::automatic + ); + + m.def("CZ", [](const QVec& control_qubits, const QVec& target_qubits) { return CZ(control_qubits, target_qubits); }, + "control_qubit"_a, "target_qubit"_a, + "Create a CZ gate", + py::return_value_policy::automatic + ); + + m.def("CZ", [](int control_qaddr, int target_qaddr) { return CZ(control_qaddr, target_qaddr); }, + "control qubit addr"_a, "target qubit addr"_a, + "Create a CZ gate", + py::return_value_policy::automatic + ); + + m.def("CZ", [](const std::vector& control_qaddrs, const std::vector& target_qaddrs) { return CZ(control_qaddrs, target_qaddrs); }, + "control qubit addr"_a, "target qubit addr"_a, + "Create a CZ gate", py::return_value_policy::automatic ); @@ -509,47 +765,82 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic ); + m.def("SWAP", [](const QVec& control_qubits, const QVec& target_qubits) { return SWAP(control_qubits, target_qubits); }, + "control_qubit"_a, "target_qubit"_a, + "Create a SWAP gate", + py::return_value_policy::automatic + ); + m.def("SWAP", [](int control_qaddr, int target_qaddr) { return SWAP(control_qaddr, target_qaddr); }, "control qubit addr"_a, "target qubit addr"_a, "Create a SWAP gate", py::return_value_policy::automatic ); - m.def("U4", [](QStat & matrix, Qubit *qubit) - {return U4(matrix, qubit); }, "matrix"_a, "qubit"_a, - "Create a U4 gate", - py::return_value_policy::automatic - ); - - m.def("U4", [](double alpha, double beta, double gamma, double delta, - Qubit * qubit) - {return U4(alpha, beta, gamma, delta, qubit); }, "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, "qubit"_a, - "Create a U4 gate", - py::return_value_policy::automatic - ); - - m.def("CU", [](double alpha, double beta, double gamma, double delta, - Qubit * controlQBit, Qubit * targetQBit) - {return CU(alpha, beta, gamma, delta, controlQBit, targetQBit); }, - "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, "control_qubit"_a, "target_qubit"_a, - "Create a CU gate", - py::return_value_policy::automatic - ); - - m.def("CU", [](QStat & matrix, Qubit * controlQBit, Qubit * targetQBit) - {return CU(matrix, controlQBit, targetQBit); }, - "matrix"_a, "control_qubit"_a, "target_qubit"_a, - "Create a CU gate", - py::return_value_policy::automatic - ); - - m.def("iSWAP", - [](Qubit* first_qubit, Qubit* second_qubit) - {return iSWAP(first_qubit, second_qubit); }, - "qubit"_a, "qubit"_a, - "Create a iSWAP gate", - py::return_value_policy::automatic - ); + m.def("SWAP", [](const std::vector& control_qaddrs, const std::vector& target_qaddrs) { return SWAP(control_qaddrs, target_qaddrs); }, + "control qubit addr"_a, "target qubit addr"_a, + "Create a SWAP gate", + py::return_value_policy::automatic + ); + + m.def("U4", [](QStat & matrix, Qubit *qubit) + {return U4(matrix, qubit); }, "matrix"_a, "qubit"_a, + "Create a U4 gate", + py::return_value_policy::automatic + ); + + m.def("U4", [](double alpha, double beta, double gamma, double delta, + Qubit * qubit) + {return U4(alpha, beta, gamma, delta, qubit); }, "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, "qubit"_a, + "Create a U4 gate", + py::return_value_policy::automatic + ); + + m.def("CU", [](double alpha, double beta, double gamma, double delta, + Qubit * controlQBit, Qubit * targetQBit) + {return CU(alpha, beta, gamma, delta, controlQBit, targetQBit); }, + "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, "control_qubit"_a, "target_qubit"_a, + "Create a CU gate", + py::return_value_policy::automatic + ); + + m.def("CU", [](double alpha, double beta, double gamma, double delta, + const QVec& controlQBits, const QVec& targetQBits) + {return CU(alpha, beta, gamma, delta, controlQBits, targetQBits); }, + "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, "control_qubit"_a, "target_qubit"_a, + "Create a CU gate", + py::return_value_policy::automatic + ); + + m.def("CU", [](QStat & matrix, Qubit * controlQBit, Qubit * targetQBit) + {return CU(matrix, controlQBit, targetQBit); }, + "matrix"_a, "control_qubit"_a, "target_qubit"_a, + "Create a CU gate", + py::return_value_policy::automatic + ); + + m.def("CU", [](QStat & matrix, const QVec& controlQBits, const QVec& targetQBits) + {return CU(matrix, controlQBits, targetQBits); }, + "matrix"_a, "control_qubit"_a, "target_qubit"_a, + "Create a CU gate", + py::return_value_policy::automatic + ); + + m.def("iSWAP", + [](Qubit* first_qubit, Qubit* second_qubit) + {return iSWAP(first_qubit, second_qubit); }, + "qubit"_a, "qubit"_a, + "Create a iSWAP gate", + py::return_value_policy::automatic + ); + + m.def("iSWAP", + [](const QVec& first_qubits, const QVec& second_qubits) + {return iSWAP(first_qubits, second_qubits); }, + "qubit"_a, "qubit"_a, + "Create a iSWAP gate", + py::return_value_policy::automatic + ); m.def("iSWAP", [](int first_qaddr, int second_qaddr) {return iSWAP(first_qaddr, second_qaddr); }, @@ -558,13 +849,28 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic ); - m.def("iSWAP", - [](Qubit* first_qubit, Qubit* second_qubit, double theta) - {return iSWAP(first_qubit, second_qubit, theta); }, - "qubit"_a, "qubit"_a, "angle"_a, - "Create a iSWAP gate", - py::return_value_policy::automatic - ); + m.def("iSWAP", [](const std::vector& first_qaddrs, const std::vector& second_qaddrs) + {return iSWAP(first_qaddrs, second_qaddrs); }, + "qubit addr"_a, "qubit addr"_a, + "Create a iSWAP gate", + py::return_value_policy::automatic + ); + + m.def("iSWAP", + [](Qubit* first_qubit, Qubit* second_qubit, double theta) + {return iSWAP(first_qubit, second_qubit, theta); }, + "qubit"_a, "qubit"_a, "angle"_a, + "Create a iSWAP gate", + py::return_value_policy::automatic + ); + + m.def("iSWAP", + [](const QVec& first_qubits, const QVec& second_qubits, double theta) + {return iSWAP(first_qubits, second_qubits, theta); }, + "qubit"_a, "qubit"_a, "angle"_a, + "Create a iSWAP gate", + py::return_value_policy::automatic + ); m.def("iSWAP", [](int first_qaddr, int second_qaddr, double theta) {return iSWAP(first_qaddr, second_qaddr, theta); }, @@ -573,13 +879,28 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic ); - m.def("SqiSWAP", - [](Qubit* first_qubit, Qubit* second_qubit) - {return SqiSWAP(first_qubit, second_qubit); }, - "qubit"_a, "qubit"_a, - "Create a SqiSWAP gate", - py::return_value_policy::automatic - ); + m.def("iSWAP", [](const std::vector& first_qaddrs, const std::vector& second_qaddrs, double theta) + {return iSWAP(first_qaddrs, second_qaddrs, theta); }, + "qubit addr"_a, "qubit addr"_a, "angle"_a, + "Create a iSWAP gate", + py::return_value_policy::automatic + ); + + m.def("SqiSWAP", + [](Qubit* first_qubit, Qubit* second_qubit) + {return SqiSWAP(first_qubit, second_qubit); }, + "qubit"_a, "qubit"_a, + "Create a SqiSWAP gate", + py::return_value_policy::automatic + ); + + m.def("SqiSWAP", + [](const QVec& first_qubits, const QVec& second_qubits) + {return SqiSWAP(first_qubits, second_qubits); }, + "qubit"_a, "qubit"_a, + "Create a SqiSWAP gate", + py::return_value_policy::automatic + ); m.def("SqiSWAP", [](int first_qaddr, int second_qaddr) {return SqiSWAP(first_qaddr, second_qaddr); }, @@ -588,394 +909,512 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic ); + m.def("SqiSWAP", [](const std::vector& first_qaddrs, const std::vector& second_qaddrs) + {return SqiSWAP(first_qaddrs, second_qaddrs); }, + "qubit addr"_a, "qubit addr"_a, + "Create a SqiSWAP gate", + py::return_value_policy::automatic + ); + + m.def("CP", [](Qubit* control_qubit, Qubit* target_qubit, double theta) + { return CP(control_qubit, target_qubit, theta); }, + "control_qubit"_a, "target_qubit"_a, "angle"_a, + "Create a CP gate", + py::return_value_policy::automatic + ); + + m.def("CP", [](const QVec& control_qubits, const QVec& target_qubits, double theta) + { return CP(control_qubits, target_qubits, theta); }, + "control_qubit"_a, "target_qubit"_a, "angle"_a, + "Create a CP gate", + py::return_value_policy::automatic + ); + + m.def("CP", [](int control_qaddr, int target_qaddr, double theta) + { return CP(control_qaddr, target_qaddr, theta); }, + "control qubit addr"_a, "target qubit addr"_a, "angle"_a, + "Create a CP gate", + py::return_value_policy::automatic + ); + + m.def("CP", [](const std::vector& control_qaddrs, const std::vector& target_qaddrs, double theta) + { return CP(control_qaddrs, target_qaddrs, theta); }, + "control qubit addr"_a, "target qubit addr"_a, "angle"_a, + "Create a CP gate", + py::return_value_policy::automatic + ); + m.def("CR", [](Qubit* control_qubit, Qubit* target_qubit, double theta) - { return CR(control_qubit, target_qubit, theta); }, + { return CR(control_qubit, target_qubit, theta); }, + "control_qubit"_a, "target_qubit"_a, "angle"_a, + "Create a CR gate", + py::return_value_policy::automatic + ); + + m.def("CR", [](const QVec& control_qubits, const QVec& target_qubits, double theta) + { return CR(control_qubits, target_qubits, theta); }, "control_qubit"_a, "target_qubit"_a, "angle"_a, "Create a CR gate", py::return_value_policy::automatic ); m.def("CR", [](int control_qaddr, int target_qaddr, double theta) - { return CR(control_qaddr, target_qaddr, theta); }, + { return CR(control_qaddr, target_qaddr, theta); }, + "control qubit addr"_a, "target qubit addr"_a, "angle"_a, + "Create a CR gate", + py::return_value_policy::automatic + ); + + m.def("CR", [](const std::vector& control_qaddrs, const std::vector& target_qaddrs, double theta) + { return CR(control_qaddrs, target_qaddrs, theta); }, "control qubit addr"_a, "target qubit addr"_a, "angle"_a, "Create a CR gate", py::return_value_policy::automatic ); - /* new interface */ - m.def("U4", [](Qubit *qubit, QStat & matrix) - {return U4(qubit, matrix); }, "matrix"_a, "qubit"_a, - "Create a U4 gate", - py::return_value_policy::automatic - ); + /* new interface */ + m.def("U4", [](Qubit *qubit, QStat & matrix) + {return U4(qubit, matrix); }, "matrix"_a, "qubit"_a, + "Create a U4 gate", + py::return_value_policy::automatic + ); + + m.def("U4", [](const QVec& qubits, QStat & matrix) + {return U4(qubits, matrix); }, "matrix"_a, "qubit"_a, + "Create a U4 gate", + py::return_value_policy::automatic + ); + + m.def("U4", [](int qaddr, QStat& matrix) {return U4(qaddr, matrix); }, + "matrix"_a, "qubit addr"_a, + "Create a U4 gate", + py::return_value_policy::automatic + ); + + m.def("U4", [](const std::vector& qaddrs, QStat& matrix) {return U4(qaddrs, matrix); }, + "matrix"_a, "qubit addr"_a, + "Create a U4 gate", + py::return_value_policy::automatic + ); + + m.def("U4", [](Qubit * qubit, double alpha, double beta, double gamma, double delta) + {return U4(qubit, alpha, beta, gamma, delta); }, "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, "qubit"_a, + "Create a U4 gate", + py::return_value_policy::automatic + ); + + m.def("U4", [](const QVec& qubits, double alpha, double beta, double gamma, double delta) + {return U4(qubits, alpha, beta, gamma, delta); }, "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, "qubit"_a, + "Create a U4 gate", + py::return_value_policy::automatic + ); + + m.def("U4", [](int qaddr, double alpha, double beta, double gamma, double delta) + {return U4(qaddr, alpha, beta, gamma, delta); }, + "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, "qubit"_a, + "Create a U4 gate", + py::return_value_policy::automatic + ); + + m.def("U4", [](const std::vector& qaddrs, double alpha, double beta, double gamma, double delta) + {return U4(qaddrs, alpha, beta, gamma, delta); }, + "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, "qubit"_a, + "Create a U4 gate", + py::return_value_policy::automatic + ); + + m.def("CU", [](Qubit * controlQBit, Qubit * targetQBit, + double alpha, double beta, double gamma, double delta) + {return CU(controlQBit, targetQBit, alpha, beta, gamma, delta); }, + "control_qubit"_a, "target_qubit"_a, "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, + "Create a CU gate", + py::return_value_policy::automatic + ); + + m.def("CU", [](const QVec& controlQBits, const QVec& targetQBits, + double alpha, double beta, double gamma, double delta) + {return CU(controlQBits, targetQBits, alpha, beta, gamma, delta); }, + "control_qubit"_a, "target_qubit"_a, "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, + "Create a CU gate", + py::return_value_policy::automatic + ); + + m.def("CU", [](int control_qaddr, int target_qaddr, + double alpha, double beta, double gamma, double delta) + { return CU(control_qaddr, target_qaddr, alpha, beta, gamma, delta); }, + "control qubit addr"_a, "target qubit addr"_a, "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, + "Create a CU gate", + py::return_value_policy::automatic + ); + + m.def("CU", [](const std::vector& control_qaddrs, const std::vector& target_qaddrs, + double alpha, double beta, double gamma, double delta) + { return CU(control_qaddrs, target_qaddrs, alpha, beta, gamma, delta); }, + "control qubit addr"_a, "target qubit addr"_a, "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, + "Create a CU gate", + py::return_value_policy::automatic + ); + + m.def("CU", [](Qubit * controlQBit, Qubit * targetQBit, QStat & matrix) + {return CU(controlQBit, targetQBit, matrix); }, + "control_qubit"_a, "target_qubit"_a, "matrix"_a, + "Create a CU gate", + py::return_value_policy::automatic + ); + + m.def("CU", [](const QVec& controlQBits, const QVec& targetQBits, QStat & matrix) + {return CU(controlQBits, targetQBits, matrix); }, + "control_qubit"_a, "target_qubit"_a, "matrix"_a, + "Create a CU gate", + py::return_value_policy::automatic + ); + + m.def("CU", [](int control_qaddr, int target_qaddr, QStat& matrix) + { return CU(control_qaddr, target_qaddr, matrix); }, + "control qubit addr"_a, "target qubit addr"_a, "matrix"_a, + "Create a CU gate", + py::return_value_policy::automatic + ); + + m.def("CU", [](const std::vector& control_qaddrs, const std::vector& target_qaddrs, QStat& matrix) + { return CU(control_qaddrs, target_qaddrs, matrix); }, + "control qubit addr"_a, "target qubit addr"_a, "matrix"_a, + "Create a CU gate", + py::return_value_policy::automatic + ); + + m.def("Toffoli", [](Qubit *control_first, Qubit * target_second, Qubit * target) + { return Toffoli(control_first, target_second, target); }, + "control first qubit"_a, "control second qubit"_a, "target qubit"_a, + "Create a Toffoli gate", + py::return_value_policy::automatic + ); + + m.def("Toffoli", [](int control_first, int target_second, int target) + { return Toffoli(control_first, target_second, target); }, + "control first qubit addr"_a, "control second qubit addr"_a, "target qubit addr"_a, + "Create a Toffoli gate", + py::return_value_policy::automatic + ); + + m.def("QDouble", [](Qubit * controlQBit, Qubit * targetQBit, QStat & matrix) + {return QDouble(controlQBit, targetQBit, matrix); }, + "control_qubit"_a, "target_qubit"_a, "matrix"_a, + "Create a QDouble gate", + py::return_value_policy::automatic + ); + + m.def("QDouble", [](const QVec& controlQBits, const QVec& targetQBits, QStat & matrix) + {return QDouble(controlQBits, targetQBits, matrix); }, + "control_qubit"_a, "target_qubit"_a, "matrix"_a, + "Create a QDouble gate", + py::return_value_policy::automatic + ); + + m.def("QDouble", [](int control_qaddr, int target_qaddr, QStat& matrix) + { return QDouble(control_qaddr, target_qaddr, matrix); }, + "control qubit addr"_a, "target qubit addr"_a, "matrix"_a, + "Create a QDouble gate", + py::return_value_policy::automatic + ); + + m.def("QDouble", [](const std::vector& control_qaddrs, const std::vector target_qaddrs, QStat& matrix) + { return QDouble(control_qaddrs, target_qaddrs, matrix); }, + "control qubit addr"_a, "target qubit addr"_a, "matrix"_a, + "Create a QDouble gate", + py::return_value_policy::automatic + ); + + + m.def("print_matrix", [](QStat& mat, const int precision) { + auto mat_str = matrix_to_string(mat, precision); + std::cout << mat_str << endl; + return mat_str; + }, "mat"_a, "precision"_a = 8, + "/**\ + * @brief output matrix information to consol\ + * @ingroup Utilities\ + * @param[in] the target matrix\ + * @param[in] const int: precision, default is 8\ + */", + py::return_value_policy::automatic + ); + + m.def("is_match_topology", &isMatchTopology, "gate"_a, "vecTopoSt"_a, + "Whether the qgate matches the quantum topology", + py::return_value_policy::automatic + ); + + m.def("get_adjacent_qgate_type", [](QProg &prog, NodeIter &node_iter) + { + std::vector adjacent_nodes; + getAdjacentQGateType(prog, node_iter, adjacent_nodes); + return adjacent_nodes; + }, "get the adjacent(the front one and the back one) nodes.", + py::return_value_policy::automatic + ); + + m.def("is_swappable", &isSwappable, "prog"_a, "target_nodeItr_1"_a, "target_nodeItr_2"_a, + "judge the specialed two NodeIters whether can be exchanged", + py::return_value_policy::automatic + ); + + m.def("is_supported_qgate_type", &isSupportedGateType, "target_nodeItr"_a, + "judge if the target node is a supported QGate type", + py::return_value_policy::automatic + ); + + /* will delete */ + + m.def("to_originir", [](QProg & qn, QuantumMachine *qvm) + {return transformQProgToOriginIR(qn, qvm); }, + py::return_value_policy::automatic_reference + ); + m.def("to_originir", [](QCircuit & qn, QuantumMachine *qvm) + {return transformQProgToOriginIR(qn, qvm); }, + py::return_value_policy::automatic_reference + ); + m.def("to_originir", [](QGate & qn, QuantumMachine *qvm) + {return transformQProgToOriginIR(qn, qvm); }, + py::return_value_policy::automatic_reference + ); + m.def("to_originir", [](QIfProg & qn, QuantumMachine *qvm) + {return transformQProgToOriginIR(qn, qvm); }, + py::return_value_policy::automatic_reference + ); + m.def("to_originir", [](QWhileProg & qn, QuantumMachine *qvm) + {return transformQProgToOriginIR(qn, qvm); }, + py::return_value_policy::automatic_reference + ); + m.def("to_originir", [](QMeasure & qn, QuantumMachine *qvm) + {return transformQProgToOriginIR(qn, qvm); }, + py::return_value_policy::automatic_reference + ); + + m.def("originir_to_qprog", [](string file_path, QuantumMachine *qvm) { + QVec qv; + std::vector cv; + return transformOriginIRToQProg(file_path, qvm, qv, cv); + }, + py::return_value_policy::automatic_reference + ); + + m.def("to_Quil", &transformQProgToQuil, "program"_a, "quantum machine"_a, "QProg to Quil", + py::return_value_policy::automatic_reference + ); + + m.def("count_gate", [](QProg & qn) + {return getQGateNumber(qn); }, + "quantum_prog"_a, + "Count quantum gate num under quantum program, quantum circuit", + py::return_value_policy::automatic + ); + + m.def("count_gate", [](QCircuit & qn) + {return getQGateNumber(qn); }, + "quantum_circuit"_a, + "Count quantum gate num under quantum program, quantum circuit", + py::return_value_policy::automatic + ); + + m.def("get_clock_cycle", [](QProg prog) { + extern QuantumMachine* global_quantum_machine; + return getQProgClockCycle(prog, global_quantum_machine); + } + , "program"_a, "Get Quantum Program Clock Cycle", + py::return_value_policy::automatic_reference + ); + + m.def("get_bin_data", [](QProg prog) { /* will delete */ + + + /* new interface */ + extern QuantumMachine* global_quantum_machine; + return transformQProgToBinary(prog, global_quantum_machine); + } + , "program"_a, "Get quantum program binary data", + py::return_value_policy::automatic_reference + ); + + m.def("bin_to_prog", [](const std::vector& data, QVec & qubits, + std::vector& cbits, QProg & prog) { + extern QuantumMachine* global_quantum_machine; + return binaryQProgDataParse(global_quantum_machine, data, qubits, cbits, prog); + } + , "data"_a, "qlist"_a, "clist"_a, "program"_a, + "Parse quantum program interface for binary data vector", + py::return_value_policy::automatic_reference + ); + m.def("get_bin_str", [](QProg prog, QuantumMachine *qvm) { + auto data = transformQProgToBinary(prog, qvm); + auto base64_data = Base64::encode(data.data(), data.size()); // 将得到的二进制数据以base64的方式编码 + std::string data_str(base64_data.begin(), base64_data.end()); + return data_str; + }, "prog"_a, "quantum machine"_a, py::return_value_policy::automatic); + + /* new interface */ + + m.def("transform_qprog_to_quil", &transformQProgToQuil + , "program"_a, "quantum machine"_a, "QProg to Quil", + py::return_value_policy::automatic_reference + ); + + m.def("get_qgate_num", [](QProg & qn) + {return getQGateNumber(qn); }, + "quantum_prog"_a, + "Count quantum gate num under quantum program, quantum circuit", + py::return_value_policy::automatic + ); + + m.def("get_qgate_num", [](QCircuit & qn) + {return getQGateNumber(qn); }, + "quantum_circuit"_a, + "Count quantum gate num under quantum program, quantum circuit", + py::return_value_policy::automatic + ); + + m.def("get_qprog_clock_cycle", &get_qprog_clock_cycle, + py::arg("prog"), py::arg("qm"), py::arg("optimize") = false, "Get Quantum Program Clock Cycle", + py::return_value_policy::automatic_reference + ); + + m.def("transform_qprog_to_binary", [](QProg prog, QuantumMachine * qvm) { + return transformQProgToBinary(prog, qvm); + } + , "program"_a, "quantum machine"_a "Get quantum program binary data", + py::return_value_policy::automatic_reference + ); + + m.def("transform_qprog_to_binary", [](QProg prog, QuantumMachine * qvm, string file_path) { + + return transformQProgToBinary(prog, qvm, file_path); + } + , "program"_a, "quantum machine"_a, "file path"_a, "Get quantum program binary data", + py::return_value_policy::automatic_reference + ); + + m.def("transform_binary_data_to_qprog", [](QuantumMachine *qm, std::vector data) { + QVec qubits; + std::vector cbits; + QProg prog; + transformBinaryDataToQProg(qm, data, qubits, cbits, prog); + return prog; + } + , "QuantumMachine"_a, "data"_a, + "Parse quantum program interface for binary data", + py::return_value_policy::automatic_reference + ); + + m.def("transform_qprog_to_originir", [](QProg prog, QuantumMachine *qm) { + return transformQProgToOriginIR(prog, qm); + } + , "program"_a, "QuantumMachine"_a, "QProg to originir", + py::return_value_policy::automatic_reference + ); + + m.def("transform_originir_to_qprog", [](string file_path, QuantumMachine *qvm) { + QVec qv; + std::vector cv; + return transformOriginIRToQProg(file_path, qvm, qv, cv); + }, + py::return_value_policy::automatic_reference + ); - m.def("U4", [](int qaddr, QStat& matrix){return U4(qaddr, matrix); }, - "matrix"_a, "qubit addr"_a, - "Create a U4 gate", + m.def("validate_single_qgate_type", [](std::vector single_gates) { + py::list ret_date; + std::vector valid_gates; + auto type = validateSingleQGateType(single_gates, valid_gates); + ret_date.append(static_cast(type)); + ret_date.append(valid_gates); + return ret_date; + } + , "Single QGates"_a, "get valid QGates and valid single QGate type", py::return_value_policy::automatic - ); + ); - m.def("U4", [](Qubit * qubit, double alpha, double beta, double gamma, double delta) - {return U4(qubit, alpha, beta, gamma, delta); }, "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, "qubit"_a, - "Create a U4 gate", - py::return_value_policy::automatic - ); + m.def("validate_double_qgate_type", [](std::vector double_gates) { + py::list ret_data; + std::vector valid_gates; + auto type = validateDoubleQGateType(double_gates, valid_gates); + ret_data.append(static_cast(type)); + ret_data.append(valid_gates); + return ret_data; + }, "Double QGates"_a, "get valid QGates and valid double QGate type", + py::return_value_policy::automatic_reference + ); - m.def("U4", [](int qaddr, double alpha, double beta, double gamma, double delta) - {return U4(qaddr, alpha, beta, gamma, delta); }, - "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, "qubit"_a, - "Create a U4 gate", + m.def("get_unsupport_qgate_num", [](QProg prog, const vector> &gates) { + return getUnsupportQGateNum(prog, gates); + }, + "get unsupport QGate_num", py::return_value_policy::automatic - ); - - m.def("CU", [](Qubit * controlQBit, Qubit * targetQBit, - double alpha, double beta, double gamma, double delta) - {return CU(controlQBit, targetQBit, alpha, beta, gamma, delta); }, - "control_qubit"_a, "target_qubit"_a, "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, - "Create a CU gate", - py::return_value_policy::automatic - ); + ); - m.def("CU", [](int control_qaddr, int target_qaddr, - double alpha, double beta, double gamma, double delta) - { return CU(control_qaddr, target_qaddr, alpha, beta, gamma, delta); }, - "control qubit addr"_a, "target qubit addr"_a, "alpha"_a, "beta"_a, "delta"_a, "gamma"_a, - "Create a CU gate", + m.def("get_qgate_num", [](QProg prog) { + return getQGateNum(prog); + }, + "get QGate_num", py::return_value_policy::automatic - ); + ); - m.def("CU", [](Qubit * controlQBit, Qubit * targetQBit, QStat & matrix) - {return CU(controlQBit, targetQBit, matrix); }, - "control_qubit"_a, "target_qubit"_a, "matrix"_a, - "Create a CU gate", - py::return_value_policy::automatic - ); + m.def("flatten", [](QProg &prog) { + flatten(prog); + }, + "flatten quantum program", + py::return_value_policy::automatic + ); - m.def("CU", [](int control_qaddr, int target_qaddr, QStat& matrix) - { return CU(control_qaddr, target_qaddr, matrix); }, - "control qubit addr"_a, "target qubit addr"_a, "matrix"_a, - "Create a CU gate", + m.def("flatten", [](QCircuit &circuit) { + flatten(circuit); + }, + "flatten quantum circuit", py::return_value_policy::automatic - ); + ); - m.def("Toffoli", [](Qubit *control_first, Qubit * target_second, Qubit * target) - { return Toffoli(control_first, target_second, target); }, - "control first qubit"_a, "control second qubit"_a, "target qubit"_a, - "Create a Toffoli gate", - py::return_value_policy::automatic - ); + m.def("convert_qprog_to_binary", [](QProg prog, QuantumMachine * qvm) { + return convert_qprog_to_binary(prog, qvm); + } + , "program"_a, "quantum machine"_a "get quantum program binary data", + py::return_value_policy::automatic_reference + ); - m.def("Toffoli", [](int control_first, int target_second, int target) - { return Toffoli(control_first, target_second, target); }, - "control first qubit addr"_a, "control second qubit addr"_a, "target qubit addr"_a, - "Create a Toffoli gate", - py::return_value_policy::automatic - ); + m.def("convert_qprog_to_binary", [](QProg prog, QuantumMachine * qvm, string file_path) { + convert_qprog_to_binary(prog, qvm, file_path); + } + , "program"_a, "quantum machine"_a, "file path"_a, "store quantum program in binary file ", + py::return_value_policy::automatic_reference + ); - m.def("QDouble", [](Qubit * controlQBit, Qubit * targetQBit, QStat & matrix) - {return QDouble(controlQBit, targetQBit, matrix); }, - "control_qubit"_a, "target_qubit"_a, "matrix"_a, - "Create a QDouble gate", - py::return_value_policy::automatic - ); + m.def("convert_binary_data_to_qprog", [](QuantumMachine *qm, std::vector data) { + QVec qubits; + std::vector cbits; + QProg prog; + convert_binary_data_to_qprog(qm, data, qubits, cbits, prog); + return prog; + } + , "QuantumMachine"_a, "data"_a, + "Parse quantum program interface for binary data", + py::return_value_policy::automatic_reference + ); - m.def("QDouble", [](int control_qaddr, int target_qaddr, QStat& matrix) - { return QDouble(control_qaddr, target_qaddr, matrix); }, - "control qubit addr"_a, "target qubit addr"_a, "matrix"_a, - "Create a QDouble gate", - py::return_value_policy::automatic - ); + m.def("convert_originir_to_qprog", [](std::string file_path, QuantumMachine* qvm) { + py::list ret_data; + QVec qv; + std::vector cv; + QProg prog = convert_originir_to_qprog(file_path, qvm, qv, cv); + py::list qubit_list; + for (auto q : qv) + qubit_list.append(q); + ret_data.append(prog); + ret_data.append(qubit_list); + ret_data.append(cv); - m.def("print_matrix", [](QStat& mat, const int precision) { - auto mat_str = matrix_to_string(mat, precision); - std::cout << mat_str << endl; - return mat_str; - }, "mat"_a, "precision"_a = 8, - "/**\ - * @brief output matrix information to consol\ - * @ingroup Utilities\ - * @param[in] the target matrix\ - * @param[in] const int: precision, default is 8\ - */", - py::return_value_policy::automatic - ); - - m.def("is_match_topology", &isMatchTopology, "gate"_a, "vecTopoSt"_a, - "Whether the qgate matches the quantum topology", - py::return_value_policy::automatic - ); - - m.def("get_adjacent_qgate_type", [](QProg &prog, NodeIter &node_iter) - { - std::vector adjacent_nodes; - getAdjacentQGateType(prog, node_iter, adjacent_nodes); - return adjacent_nodes; - }, "get the adjacent(the front one and the back one) nodes.", - py::return_value_policy::automatic - ); - - m.def("is_swappable", &isSwappable, "prog"_a, "target_nodeItr_1"_a, "target_nodeItr_2"_a, - "judge the specialed two NodeIters whether can be exchanged", - py::return_value_policy::automatic - ); - - m.def("is_supported_qgate_type", &isSupportedGateType, "target_nodeItr"_a, - "judge if the target node is a supported QGate type", - py::return_value_policy::automatic - ); - - /* will delete */ - - m.def("to_originir", [](QProg & qn, QuantumMachine *qvm) - {return transformQProgToOriginIR(qn, qvm); }, - py::return_value_policy::automatic_reference - ); - m.def("to_originir", [](QCircuit & qn, QuantumMachine *qvm) - {return transformQProgToOriginIR(qn, qvm); }, - py::return_value_policy::automatic_reference - ); - m.def("to_originir", [](QGate & qn, QuantumMachine *qvm) - {return transformQProgToOriginIR(qn, qvm); }, - py::return_value_policy::automatic_reference - ); - m.def("to_originir", [](QIfProg & qn, QuantumMachine *qvm) - {return transformQProgToOriginIR(qn, qvm); }, - py::return_value_policy::automatic_reference - ); - m.def("to_originir", [](QWhileProg & qn, QuantumMachine *qvm) - {return transformQProgToOriginIR(qn, qvm); }, - py::return_value_policy::automatic_reference - ); - m.def("to_originir", [](QMeasure & qn, QuantumMachine *qvm) - {return transformQProgToOriginIR(qn, qvm); }, - py::return_value_policy::automatic_reference - ); - - m.def("originir_to_qprog", [](string file_path, QuantumMachine *qvm) { - QVec qv; - std::vector cv; - return transformOriginIRToQProg(file_path, qvm, qv, cv); - }, - py::return_value_policy::automatic_reference - ); - - m.def("to_Quil", &transformQProgToQuil, "program"_a, "quantum machine"_a, "QProg to Quil", - py::return_value_policy::automatic_reference - ); - - m.def("count_gate", [](QProg & qn) - {return getQGateNumber(qn); }, - "quantum_prog"_a, - "Count quantum gate num under quantum program, quantum circuit", - py::return_value_policy::automatic - ); - - m.def("count_gate", [](QCircuit & qn) - {return getQGateNumber(qn); }, - "quantum_circuit"_a, - "Count quantum gate num under quantum program, quantum circuit", - py::return_value_policy::automatic - ); - - m.def("get_clock_cycle", [](QProg prog) { - extern QuantumMachine* global_quantum_machine; - return getQProgClockCycle(prog, global_quantum_machine); - } - , "program"_a, "Get Quantum Program Clock Cycle", - py::return_value_policy::automatic_reference - ); - - m.def("get_bin_data", [](QProg prog) { /* will delete */ - - - /* new interface */ - extern QuantumMachine* global_quantum_machine; - return transformQProgToBinary(prog, global_quantum_machine); - } - , "program"_a, "Get quantum program binary data", - py::return_value_policy::automatic_reference - ); - - m.def("bin_to_prog", [](const std::vector& data, QVec & qubits, - std::vector& cbits, QProg & prog) { - extern QuantumMachine* global_quantum_machine; - return binaryQProgDataParse(global_quantum_machine, data, qubits, cbits, prog); - } - , "data"_a, "qlist"_a, "clist"_a, "program"_a, - "Parse quantum program interface for binary data vector", - py::return_value_policy::automatic_reference - ); - m.def("get_bin_str", [](QProg prog, QuantumMachine *qvm) { - auto data = transformQProgToBinary(prog, qvm); - auto base64_data = Base64::encode(data.data(), data.size()); // 将得到的二进制数据以base64的方式编码 - std::string data_str(base64_data.begin(), base64_data.end()); - return data_str; - }, "prog"_a, "quantum machine"_a, py::return_value_policy::automatic); - - /* new interface */ - - m.def("transform_qprog_to_quil", &transformQProgToQuil - , "program"_a, "quantum machine"_a, "QProg to Quil", - py::return_value_policy::automatic_reference - ); - - m.def("get_qgate_num", [](QProg & qn) - {return getQGateNumber(qn); }, - "quantum_prog"_a, - "Count quantum gate num under quantum program, quantum circuit", - py::return_value_policy::automatic - ); - - m.def("get_qgate_num", [](QCircuit & qn) - {return getQGateNumber(qn); }, - "quantum_circuit"_a, - "Count quantum gate num under quantum program, quantum circuit", - py::return_value_policy::automatic - ); - - m.def("get_qprog_clock_cycle", &get_qprog_clock_cycle, - py::arg("prog"), py::arg("qm"), py::arg("optimize") = false, "Get Quantum Program Clock Cycle", - py::return_value_policy::automatic_reference - ); - - m.def("transform_qprog_to_binary", [](QProg prog, QuantumMachine * qvm) { - return transformQProgToBinary(prog, qvm); - } - , "program"_a, "quantum machine"_a "Get quantum program binary data", - py::return_value_policy::automatic_reference - ); - - m.def("transform_qprog_to_binary", [](QProg prog, QuantumMachine * qvm, string file_path) { - - return transformQProgToBinary(prog, qvm, file_path); - } - , "program"_a, "quantum machine"_a, "file path"_a, "Get quantum program binary data", - py::return_value_policy::automatic_reference - ); - - m.def("transform_binary_data_to_qprog", [](QuantumMachine *qm, std::vector data) { - QVec qubits; - std::vector cbits; - QProg prog; - transformBinaryDataToQProg(qm, data, qubits, cbits, prog); - return prog; - } - , "QuantumMachine"_a, "data"_a, - "Parse quantum program interface for binary data", - py::return_value_policy::automatic_reference - ); - - m.def("transform_qprog_to_originir", [](QProg prog, QuantumMachine *qm) { - return transformQProgToOriginIR(prog, qm); - } - , "program"_a, "QuantumMachine"_a, "QProg to originir", - py::return_value_policy::automatic_reference - ); - - m.def("transform_originir_to_qprog", [](string file_path, QuantumMachine *qvm) { - QVec qv; - std::vector cv; - return transformOriginIRToQProg(file_path, qvm, qv, cv); - }, - py::return_value_policy::automatic_reference - ); - - m.def("validate_single_qgate_type", [](std::vector single_gates) { - py::list ret_date; - std::vector valid_gates; - auto type = validateSingleQGateType(single_gates, valid_gates); - ret_date.append(static_cast(type)); - ret_date.append(valid_gates); - return ret_date; - } - , "Single QGates"_a, "get valid QGates and valid single QGate type", - py::return_value_policy::automatic - ); - - m.def("validate_double_qgate_type", [](std::vector double_gates) { - py::list ret_data; - std::vector valid_gates; - auto type = validateDoubleQGateType(double_gates, valid_gates); - ret_data.append(static_cast(type)); - ret_data.append(valid_gates); - return ret_data; - }, "Double QGates"_a, "get valid QGates and valid double QGate type", - py::return_value_policy::automatic_reference - ); - - m.def("get_unsupport_qgate_num", [](QProg prog, const vector> &gates) { - return getUnsupportQGateNum(prog, gates); - }, - "get unsupport QGate_num", - py::return_value_policy::automatic - ); - - m.def("get_qgate_num", [](QProg prog) { - return getQGateNum(prog); - }, - "get QGate_num", - py::return_value_policy::automatic - ); - - m.def("flatten", [](QProg &prog) { - flatten(prog); - }, - "flatten quantum program", - py::return_value_policy::automatic - ); - - m.def("flatten", [](QCircuit &circuit) { - flatten(circuit); - }, - "flatten quantum circuit", - py::return_value_policy::automatic - ); - - m.def("convert_qprog_to_binary", [](QProg prog, QuantumMachine * qvm) { - return convert_qprog_to_binary(prog, qvm); - } - , "program"_a, "quantum machine"_a "get quantum program binary data", - py::return_value_policy::automatic_reference - ); - - m.def("convert_qprog_to_binary", [](QProg prog, QuantumMachine * qvm, string file_path) { - convert_qprog_to_binary(prog, qvm, file_path); - } - , "program"_a, "quantum machine"_a, "file path"_a, "store quantum program in binary file ", - py::return_value_policy::automatic_reference - ); - - m.def("convert_binary_data_to_qprog", [](QuantumMachine *qm, std::vector data) { - QVec qubits; - std::vector cbits; - QProg prog; - convert_binary_data_to_qprog(qm, data, qubits, cbits, prog); - return prog; - } - , "QuantumMachine"_a, "data"_a, - "Parse quantum program interface for binary data", - py::return_value_policy::automatic_reference - ); - - m.def("convert_originir_to_qprog", [](std::string file_path, QuantumMachine* qvm) { - py::list ret_data; - QVec qv; - std::vector cv; - QProg prog = convert_originir_to_qprog(file_path, qvm, qv, cv); - py::list qubit_list; - for (auto q : qv) - qubit_list.append(q); - - ret_data.append(prog); - ret_data.append(qubit_list); - ret_data.append(cv); - - return ret_data; - }, - "file_name"_a, "QuantumMachine"_a, "convert OriginIR to QProg", - py::return_value_policy::automatic_reference - ); + return ret_data; + }, + "file_name"_a, "QuantumMachine"_a, "convert OriginIR to QProg", + py::return_value_policy::automatic_reference + ); m.def("convert_originir_str_to_qprog", [](std::string originir_str, QuantumMachine* qvm) { py::list ret_data; @@ -1003,212 +1442,212 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic_reference ); - m.def("convert_qprog_to_quil", &convert_qprog_to_quil, - "quantum program"_a, "quantum machine"_a, "convert QProg to Quil", - py::return_value_policy::automatic_reference - ); - - - m.def("convert_qasm_string_to_qprog", [](std::string qasm_str, QuantumMachine* qvm) { - py::list ret_data; - QVec qv; - std::vector cv; - QProg prog = convert_qasm_string_to_qprog(qasm_str, qvm, qv, cv); - py::list qubit_list; - for (auto q : qv) - qubit_list.append(q); - - ret_data.append(prog); - ret_data.append(qubit_list); - ret_data.append(cv); - return ret_data; - }, - "file_name"_a, "quantum machine"_a, "convert QASM to QProg", - py::return_value_policy::automatic_reference - ); - - m.def("convert_qasm_to_qprog", [](std::string file_path, QuantumMachine* qvm) { - py::list ret_data; - QVec qv; - std::vector cv; - QProg prog = convert_qasm_to_qprog(file_path, qvm, qv, cv); - py::list qubit_list; - for (auto q : qv) - qubit_list.append(q); - - ret_data.append(prog); - ret_data.append(qubit_list); - ret_data.append(cv); - return ret_data; - }, - "file_name"_a, "quantum machine"_a, "convert QASM to QProg", - py::return_value_policy::automatic_reference - ); - - m.def("convert_qprog_to_qasm", [](QProg prog, QuantumMachine *qvm) { - return convert_qprog_to_qasm(prog, qvm); - }, "prog"_a, "quantum machine"_a, py::return_value_policy::automatic_reference - ); - - m.def("cast_qprog_qgate", &cast_qprog_qgate, - "quantum program"_a, "cast QProg to QGate", - py::return_value_policy::automatic_reference - ); - - m.def("cast_qprog_qmeasure", &cast_qprog_qmeasure, - "quantum program"_a, "cast QProg to QMeasure", - py::return_value_policy::automatic_reference - ); - - m.def("cast_qprog_qcircuit", [](QProg prog) { - QCircuit cir; - cast_qprog_qcircuit(prog, cir); - return cir; - } - , "quantum program"_a, "cast QProg to QCircuit", - py::return_value_policy::automatic_reference - ); - - m.def("topology_match", [](QProg prog, QVec qv, QuantumMachine *qvm, SwapQubitsMethod method, + m.def("convert_qprog_to_quil", &convert_qprog_to_quil, + "quantum program"_a, "quantum machine"_a, "convert QProg to Quil", + py::return_value_policy::automatic_reference + ); + + + m.def("convert_qasm_string_to_qprog", [](std::string qasm_str, QuantumMachine* qvm) { + py::list ret_data; + QVec qv; + std::vector cv; + QProg prog = convert_qasm_string_to_qprog(qasm_str, qvm, qv, cv); + py::list qubit_list; + for (auto q : qv) + qubit_list.append(q); + + ret_data.append(prog); + ret_data.append(qubit_list); + ret_data.append(cv); + return ret_data; + }, + "file_name"_a, "quantum machine"_a, "convert QASM to QProg", + py::return_value_policy::automatic_reference + ); + + m.def("convert_qasm_to_qprog", [](std::string file_path, QuantumMachine* qvm) { + py::list ret_data; + QVec qv; + std::vector cv; + QProg prog = convert_qasm_to_qprog(file_path, qvm, qv, cv); + py::list qubit_list; + for (auto q : qv) + qubit_list.append(q); + + ret_data.append(prog); + ret_data.append(qubit_list); + ret_data.append(cv); + return ret_data; + }, + "file_name"_a, "quantum machine"_a, "convert QASM to QProg", + py::return_value_policy::automatic_reference + ); + + m.def("convert_qprog_to_qasm", [](QProg prog, QuantumMachine *qvm) { + return convert_qprog_to_qasm(prog, qvm); + }, "prog"_a, "quantum machine"_a, py::return_value_policy::automatic_reference + ); + + m.def("cast_qprog_qgate", &cast_qprog_qgate, + "quantum program"_a, "cast QProg to QGate", + py::return_value_policy::automatic_reference + ); + + m.def("cast_qprog_qmeasure", &cast_qprog_qmeasure, + "quantum program"_a, "cast QProg to QMeasure", + py::return_value_policy::automatic_reference + ); + + m.def("cast_qprog_qcircuit", [](QProg prog) { + QCircuit cir; + cast_qprog_qcircuit(prog, cir); + return cir; + } + , "quantum program"_a, "cast QProg to QCircuit", + py::return_value_policy::automatic_reference + ); + + m.def("topology_match", [](QProg prog, QVec qv, QuantumMachine *qvm, SwapQubitsMethod method, ArchType arch_type, const std::string conf) { - py::list ret_data; - QProg out_prog = topology_match(prog, qv, qvm, method, arch_type, conf); - py::list qubit_list; - for (auto q : qv) - qubit_list.append(q); - - ret_data.append(out_prog); - ret_data.append(qubit_list); - return ret_data; - }, - "prog"_a, "qubits"_a, "quantum machine"_a, "SwapQubitsMethod"_a = CNOT_GATE_METHOD, + py::list ret_data; + QProg out_prog = topology_match(prog, qv, qvm, method, arch_type, conf); + py::list qubit_list; + for (auto q : qv) + qubit_list.append(q); + + ret_data.append(out_prog); + ret_data.append(qubit_list); + return ret_data; + }, + "prog"_a, "qubits"_a, "quantum machine"_a, "SwapQubitsMethod"_a = CNOT_GATE_METHOD, "ArchType"_a = IBM_QX5_ARCH, "conf"_a = CONFIG_PATH, - py::return_value_policy::automatic_reference - ); + py::return_value_policy::automatic_reference + ); - /* will delete */ - m.def("PMeasure", &PMeasure, - "Get the probability distribution over qubits", - py::return_value_policy::automatic - ); + /* will delete */ + m.def("PMeasure", &PMeasure, + "Get the probability distribution over qubits", + py::return_value_policy::automatic + ); - m.def("PMeasure_no_index", &PMeasure_no_index, - "Get the probability distribution over qubits", - py::return_value_policy::automatic - ); + m.def("PMeasure_no_index", &PMeasure_no_index, + "Get the probability distribution over qubits", + py::return_value_policy::automatic + ); - m.def("accumulateProbability", &accumulateProbability, - "Accumulate the probability from a prob list", - py::return_value_policy::automatic - ); - m.def("accumulate_probabilities", &accumulateProbability, "probability_list"_a, - "Accumulate the probability from a prob list", - py::return_value_policy::automatic - ); + m.def("accumulateProbability", &accumulateProbability, + "Accumulate the probability from a prob list", + py::return_value_policy::automatic + ); + m.def("accumulate_probabilities", &accumulateProbability, "probability_list"_a, + "Accumulate the probability from a prob list", + py::return_value_policy::automatic + ); - /* new interface */ + /* new interface */ - m.def("pmeasure", &pMeasure, - "Get the probability distribution over qubits", - py::return_value_policy::automatic - ); + m.def("pmeasure", &pMeasure, + "Get the probability distribution over qubits", + py::return_value_policy::automatic + ); - m.def("pmeasure_no_index", &pMeasureNoIndex, - "Get the probability distribution over qubits", - py::return_value_policy::automatic - ); + m.def("pmeasure_no_index", &pMeasureNoIndex, + "Get the probability distribution over qubits", + py::return_value_policy::automatic + ); - m.def("accumulate_probability", &accumulateProbability, "probability_list"_a, - "Accumulate the probability from a prob list", - py::return_value_policy::automatic - ); + m.def("accumulate_probability", &accumulateProbability, "probability_list"_a, + "Accumulate the probability from a prob list", + py::return_value_policy::automatic + ); - m.def("run_with_configuration", &runWithConfiguration, "program"_a, - "cbit_list"_a, - "shots"_a, - "run with configuration", - py::return_value_policy::automatic - ); + m.def("run_with_configuration", &runWithConfiguration, "program"_a, + "cbit_list"_a, + "shots"_a, + "run with configuration", + py::return_value_policy::automatic + ); - m.def("prob_run_tuple_list", probRunTupleList, "program"_a, "qubit_list"_a, "select_max"_a = -1, - py::return_value_policy::reference); - m.def("prob_run_list", probRunList, "program"_a, "qubit_list"_a, "select_max"_a = -1, - py::return_value_policy::reference); - m.def("prob_run_dict", probRunDict, "program"_a, "qubit_list"_a, "select_max"_a = -1, - py::return_value_policy::reference); + m.def("prob_run_tuple_list", probRunTupleList, "program"_a, "qubit_list"_a, "select_max"_a = -1, + py::return_value_policy::reference); + m.def("prob_run_list", probRunList, "program"_a, "qubit_list"_a, "select_max"_a = -1, + py::return_value_policy::reference); + m.def("prob_run_dict", probRunDict, "program"_a, "qubit_list"_a, "select_max"_a = -1, + py::return_value_policy::reference); - /* add */ - m.def("get_tuple_list", getProbTupleList, "qubit_list"_a, "select_max"_a = -1, - py::return_value_policy::reference); - m.def("get_prob_list", getProbList, "qubit_list"_a, "select_max"_a = -1, - py::return_value_policy::reference); - m.def("get_prob_dict", getProbDict, "qubit_list"_a, "select_max"_a = -1, - py::return_value_policy::reference); + /* add */ + m.def("get_tuple_list", getProbTupleList, "qubit_list"_a, "select_max"_a = -1, + py::return_value_policy::reference); + m.def("get_prob_list", getProbList, "qubit_list"_a, "select_max"_a = -1, + py::return_value_policy::reference); + m.def("get_prob_dict", getProbDict, "qubit_list"_a, "select_max"_a = -1, + py::return_value_policy::reference); - m.def("add", [](ClassicalCondition a, ClassicalCondition b) - {return a + b; }); + m.def("add", [](ClassicalCondition a, ClassicalCondition b) + {return a + b; }); - m.def("add", [](ClassicalCondition a, cbit_size_t b) - {return a + b; }); + m.def("add", [](ClassicalCondition a, cbit_size_t b) + {return a + b; }); - m.def("add", [](cbit_size_t a, ClassicalCondition b) - {return a + b; }); + m.def("add", [](cbit_size_t a, ClassicalCondition b) + {return a + b; }); - m.def("sub", [](ClassicalCondition a, ClassicalCondition b) - {return a - b; }); + m.def("sub", [](ClassicalCondition a, ClassicalCondition b) + {return a - b; }); - m.def("sub", [](ClassicalCondition a, cbit_size_t b) - {return a - b; }); + m.def("sub", [](ClassicalCondition a, cbit_size_t b) + {return a - b; }); - m.def("sub", [](cbit_size_t a, ClassicalCondition b) - {return a - b; }); + m.def("sub", [](cbit_size_t a, ClassicalCondition b) + {return a - b; }); - m.def("mul", [](ClassicalCondition a, ClassicalCondition b) - {return a * b; }); + m.def("mul", [](ClassicalCondition a, ClassicalCondition b) + {return a * b; }); - m.def("mul", [](ClassicalCondition a, cbit_size_t b) - {return a * b; }); + m.def("mul", [](ClassicalCondition a, cbit_size_t b) + {return a * b; }); - m.def("mul", [](cbit_size_t a, ClassicalCondition b) - {return a * b; }); + m.def("mul", [](cbit_size_t a, ClassicalCondition b) + {return a * b; }); - m.def("div", [](ClassicalCondition a, ClassicalCondition b) - {return a / b; }); + m.def("div", [](ClassicalCondition a, ClassicalCondition b) + {return a / b; }); - m.def("div", [](ClassicalCondition a, cbit_size_t b) - {return a / b; }); + m.def("div", [](ClassicalCondition a, cbit_size_t b) + {return a / b; }); - m.def("div", [](cbit_size_t a, ClassicalCondition b) - {return a / b; }); + m.def("div", [](cbit_size_t a, ClassicalCondition b) + {return a / b; }); - m.def("equal", [](ClassicalCondition a, ClassicalCondition b) - {return a == b; }); + m.def("equal", [](ClassicalCondition a, ClassicalCondition b) + {return a == b; }); - m.def("equal", [](ClassicalCondition a, cbit_size_t b) - {return a == b; }); + m.def("equal", [](ClassicalCondition a, cbit_size_t b) + {return a == b; }); - m.def("equal", [](cbit_size_t a, ClassicalCondition b) - {return a == b; }); + m.def("equal", [](cbit_size_t a, ClassicalCondition b) + {return a == b; }); - m.def("assign", [](ClassicalCondition a, ClassicalCondition b) - {return a = b; }); + m.def("assign", [](ClassicalCondition a, ClassicalCondition b) + {return a = b; }); - m.def("assign", [](ClassicalCondition a, cbit_size_t b) - {return a = b; }); + m.def("assign", [](ClassicalCondition a, cbit_size_t b) + {return a = b; }); - m.def("vector_dot", &vector_dot, "x"_a, "y"_a, "Inner product of vector x and y"); - m.def("all_cut_of_graph", &all_cut_of_graph, "generate graph of maxcut problem"); + m.def("vector_dot", &vector_dot, "x"_a, "y"_a, "Inner product of vector x and y"); + m.def("all_cut_of_graph", &all_cut_of_graph, "generate graph of maxcut problem"); - m.def("vector_dot", &vector_dot, "Inner product of vector x and y"); - m.def("all_cut_of_graph", &all_cut_of_graph, "generate graph of maxcut problem"); + m.def("vector_dot", &vector_dot, "Inner product of vector x and y"); + m.def("all_cut_of_graph", &all_cut_of_graph, "generate graph of maxcut problem"); - m.def("get_matrix", [](QProg prog, const bool b_bid_endian, const NodeIter nodeItrStart, const NodeIter nodeItrEnd) { - return getCircuitMatrix(prog, b_bid_endian, nodeItrStart, nodeItrEnd); - }, py::arg("prog"), py::arg("b_bid_endian") = false, py::arg("nodeItrStart") = NodeIter(), py::arg("nodeItrEnd") = NodeIter() - , "/**\ + m.def("get_matrix", [](QProg prog, const bool b_bid_endian, const NodeIter nodeItrStart, const NodeIter nodeItrEnd) { + return getCircuitMatrix(prog, b_bid_endian, nodeItrStart, nodeItrEnd); + }, py::arg("prog"), py::arg("b_bid_endian") = false, py::arg("nodeItrStart") = NodeIter(), py::arg("nodeItrEnd") = NodeIter() + , "/**\ * @brief get the target matrix between the input two Nodeiters\ * @ingroup Utilities\ * @param[in] const bool Qubit order mark of output matrix,\ @@ -1218,109 +1657,109 @@ PYBIND11_MODULE(pyQPanda, m) * @return the target matrix include all the QGate's matrix (multiply).\ * @see\ * / ", - py::return_value_policy::automatic - ); - - m.def("circuit_layer", [](QProg prg) { - py::list ret_data; - auto layer_info = prog_layer(prg); - std::vector> tmp_layer(layer_info.size()); - size_t layer_index = 0; - for (auto& cur_layer : layer_info) - { - for (auto& node_item : cur_layer) - { - const pOptimizerNodeInfo& n = node_item.first; - //single gate first - if ((node_item.first->m_control_qubits.size() == 0) && (node_item.first->m_target_qubits.size() == 1)) - { - tmp_layer[layer_index].insert(tmp_layer[layer_index].begin(), - NodeInfo(n->m_iter, n->m_target_qubits, - n->m_control_qubits, n->m_type, - n->m_is_dagger)); - } - else - { - tmp_layer[layer_index].push_back(NodeInfo(n->m_iter, n->m_target_qubits, - n->m_control_qubits, n->m_type, - n->m_is_dagger)); - } - } - - ++layer_index; - } - ret_data.append(tmp_layer); - - std::vector vec_qubits_in_use; - get_all_used_qubits(prg, vec_qubits_in_use); - ret_data.append(vec_qubits_in_use); - - std::vector vec_cbits_in_use; - get_all_used_class_bits(prg, vec_cbits_in_use); - ret_data.append(vec_cbits_in_use); - - return ret_data; - }, py::arg("prog"), - "quantum circuit layering", - py::return_value_policy::automatic - ); - - m.def("draw_qprog_text", [](QProg prg, uint32_t auto_wrap_len, bool b_out_put_to_file, const NodeIter itr_start, const NodeIter itr_end) { - return draw_qprog(prg, auto_wrap_len, b_out_put_to_file, itr_start, itr_end); - }, py::arg("prog"), py::arg("auto_wrap_len") = 100, py::arg("b_out_put_to_file") = false, py::arg("itr_start") = NodeIter(), py::arg("itr_end") = NodeIter(), - "Convert a quantum prog/circuit to text-pic(UTF-8 code), \ + py::return_value_policy::automatic + ); + + m.def("circuit_layer", [](QProg prg) { + py::list ret_data; + auto layer_info = prog_layer(prg); + std::vector> tmp_layer(layer_info.size()); + size_t layer_index = 0; + for (auto& cur_layer : layer_info) + { + for (auto& node_item : cur_layer) + { + const pOptimizerNodeInfo& n = node_item.first; + //single gate first + if ((node_item.first->m_control_qubits.size() == 0) && (node_item.first->m_target_qubits.size() == 1)) + { + tmp_layer[layer_index].insert(tmp_layer[layer_index].begin(), + NodeInfo(n->m_iter, n->m_target_qubits, + n->m_control_qubits, n->m_type, + n->m_is_dagger)); + } + else + { + tmp_layer[layer_index].push_back(NodeInfo(n->m_iter, n->m_target_qubits, + n->m_control_qubits, n->m_type, + n->m_is_dagger)); + } + } + + ++layer_index; + } + ret_data.append(tmp_layer); + + std::vector vec_qubits_in_use; + get_all_used_qubits(prg, vec_qubits_in_use); + ret_data.append(vec_qubits_in_use); + + std::vector vec_cbits_in_use; + get_all_used_class_bits(prg, vec_cbits_in_use); + ret_data.append(vec_cbits_in_use); + + return ret_data; + }, py::arg("prog"), + "quantum circuit layering", + py::return_value_policy::automatic + ); + + m.def("draw_qprog_text", [](QProg prg, uint32_t auto_wrap_len, bool b_out_put_to_file, const NodeIter itr_start, const NodeIter itr_end) { + return draw_qprog(prg, auto_wrap_len, b_out_put_to_file, itr_start, itr_end); + }, py::arg("prog"), py::arg("auto_wrap_len") = 100, py::arg("b_out_put_to_file") = false, py::arg("itr_start") = NodeIter(), py::arg("itr_end") = NodeIter(), + "Convert a quantum prog/circuit to text-pic(UTF-8 code), \ and will save the text-pic in file named QCircuitTextPic.txt in the same time in current path", - py::return_value_policy::automatic - ); + py::return_value_policy::automatic + ); - m.def("fit_to_gbk", &fit_to_gbk, py::arg("utf8_str"), - "Adapting utf8 characters to GBK", - py::return_value_policy::automatic - ); + m.def("fit_to_gbk", &fit_to_gbk, py::arg("utf8_str"), + "Adapting utf8 characters to GBK", + py::return_value_policy::automatic + ); - m.def("draw_qprog_text_with_clock", [](QProg prog, const std::string config_data, uint32_t auto_wrap_len, + m.def("draw_qprog_text_with_clock", [](QProg prog, const std::string config_data, uint32_t auto_wrap_len, bool b_out_put_to_file, const NodeIter itr_start, const NodeIter itr_end) { - return draw_qprog_with_clock(prog, config_data, auto_wrap_len, b_out_put_to_file, itr_start, itr_end); - }, py::arg("prog"), py::arg("config_data") = CONFIG_PATH, py::arg("auto_wrap_len") = 100, + return draw_qprog_with_clock(prog, config_data, auto_wrap_len, b_out_put_to_file, itr_start, itr_end); + }, py::arg("prog"), py::arg("config_data") = CONFIG_PATH, py::arg("auto_wrap_len") = 100, py::arg("b_out_put_to_file") = false, py::arg("itr_start") = NodeIter(), py::arg("itr_end") = NodeIter(), - "Convert a quantum prog/circuit to text-pic(UTF-8 code) with time sequence, \ + "Convert a quantum prog/circuit to text-pic(UTF-8 code) with time sequence, \ and will save the text-pic in file named QCircuitTextPic.txt in the same time in current path", - py::return_value_policy::automatic - ); - - m.def("fill_qprog_by_I", [](QProg &prg) { - return fill_qprog_by_I(prg); - }, py::arg("prog"), - "Fill the input QProg by I gate, get a new quantum program", - py::return_value_policy::automatic - ); - -//#define QUERY_REPLACE(GRAPH_NODE,QUERY_NODE,REPLACE_NODE) \ -// m.def("graph_query_replace", [](GRAPH_NODE &graph_node, QUERY_NODE &query_node,\ -// REPLACE_NODE &replace_node, QuantumMachine *qvm)\ -// {\ -// QProg prog;\ -// graph_query_replace(graph_node, query_node, replace_node, prog, qvm); \ -// return prog;\ -// },py::return_value_policy::automatic); - - m.def("quantum_chip_adapter", [](QProg prog, QuantumMachine *quantum_machine, bool b_mapping = true, - const std::string config_data = CONFIG_PATH) { - py::list ret_data; - - QVec new_qvec; - quantum_chip_adapter(prog, quantum_machine, new_qvec, b_mapping, config_data); - if (!b_mapping) - { - get_all_used_qubits(prog, new_qvec); - } - - ret_data.append(prog); - ret_data.append(new_qvec); - return ret_data; - }, "prog"_a, "quantum_machine"_a, "b_mapping"_a = true, "config_data"_a = CONFIG_PATH, - "/**\ + py::return_value_policy::automatic + ); + + m.def("fill_qprog_by_I", [](QProg &prg) { + return fill_qprog_by_I(prg); + }, py::arg("prog"), + "Fill the input QProg by I gate, get a new quantum program", + py::return_value_policy::automatic + ); + + //#define QUERY_REPLACE(GRAPH_NODE,QUERY_NODE,REPLACE_NODE) \ + // m.def("graph_query_replace", [](GRAPH_NODE &graph_node, QUERY_NODE &query_node,\ + // REPLACE_NODE &replace_node, QuantumMachine *qvm)\ + // {\ + // QProg prog;\ + // graph_query_replace(graph_node, query_node, replace_node, prog, qvm); \ + // return prog;\ + // },py::return_value_policy::automatic); + + m.def("quantum_chip_adapter", [](QProg prog, QuantumMachine *quantum_machine, bool b_mapping = true, + const std::string config_data = CONFIG_PATH) { + py::list ret_data; + + QVec new_qvec; + quantum_chip_adapter(prog, quantum_machine, new_qvec, b_mapping, config_data); + if (!b_mapping) + { + get_all_used_qubits(prog, new_qvec); + } + + ret_data.append(prog); + ret_data.append(new_qvec); + return ret_data; + }, "prog"_a, "quantum_machine"_a, "b_mapping"_a = true, "config_data"_a = CONFIG_PATH, + "/**\ * @brief Quantum chip adaptive conversion\ * @ingroup Utilities\ * @param[in] QProg Quantum Program\ @@ -1332,15 +1771,15 @@ PYBIND11_MODULE(pyQPanda, m) so the configuration file must be end with \".json\", default is CONFIG_PATH\ * @return The new quantum program and the mapped qubit vector\ * / ", - py::return_value_policy::automatic - ); - - m.def("decompose_multiple_control_qgate", [](QProg prog, QuantumMachine *quantum_machine, - const std::string config_data = CONFIG_PATH) { - decompose_multiple_control_qgate(prog, quantum_machine, config_data); - return prog; - }, "prog"_a, "quantum_machine"_a, "config_data"_a = CONFIG_PATH, - "/**\ + py::return_value_policy::automatic + ); + + m.def("decompose_multiple_control_qgate", [](QProg prog, QuantumMachine *quantum_machine, + const std::string config_data = CONFIG_PATH) { + decompose_multiple_control_qgate(prog, quantum_machine, config_data); + return prog; + }, "prog"_a, "quantum_machine"_a, "config_data"_a = CONFIG_PATH, + "/**\ * @brief Decompose multiple control QGate\ * @param[in] QProg& Quantum Program\ * @param[in] QuantumMachine* quantum machine pointer\ @@ -1348,15 +1787,15 @@ PYBIND11_MODULE(pyQPanda, m) so the configuration file must be end with \".json\", default is CONFIG_PATH\ * @return new Qprog\ * / ", - py::return_value_policy::automatic - ); - - m.def("transform_to_base_qgate", [](QProg prog, QuantumMachine *quantum_machine, - const std::string config_data = CONFIG_PATH) { - transform_to_base_qgate(prog, quantum_machine, config_data); - return prog; - }, "prog"_a, "quantum_machine"_a, "config_data"_a = CONFIG_PATH, - "/**\ + py::return_value_policy::automatic + ); + + m.def("transform_to_base_qgate", [](QProg prog, QuantumMachine *quantum_machine, + const std::string config_data = CONFIG_PATH) { + transform_to_base_qgate(prog, quantum_machine, config_data); + return prog; + }, "prog"_a, "quantum_machine"_a, "config_data"_a = CONFIG_PATH, + "/**\ * @brief Basic quantum - gate conversion\ * @param[in] QProg& Quantum Program\ * @param[in] QuantumMachine* quantum machine pointer\ @@ -1365,19 +1804,19 @@ PYBIND11_MODULE(pyQPanda, m) * @return\ * @note Quantum circuits or programs cannot contain multiple-control gates.\ * / ", - py::return_value_policy::automatic - ); + py::return_value_policy::automatic + ); - m.def("circuit_optimizer", [](QProg prog, const std::vector>& optimizer_cir_vec, - const std::vector& mode_list = std::vector(0)) { + m.def("circuit_optimizer", [](QProg prog, const std::vector>& optimizer_cir_vec, + const std::vector& mode_list = std::vector(0)) { int mode = 0; - for (const auto& m : mode_list){ + for (const auto& m : mode_list) { mode |= m; } - cir_optimizer(prog, optimizer_cir_vec, mode); - return prog; - }, "prog"_a, "optimizer_cir_vec"_a = std::vector>(), "mode_list"_a = std::vector(0), - "/**\ + cir_optimizer(prog, optimizer_cir_vec, mode); + return prog; + }, "prog"_a, "optimizer_cir_vec"_a = std::vector>(), "mode_list"_a = std::vector(0), + "/**\ * @brief QCircuit optimizer\ * @ingroup Utilities\ * @param[in, out] QProg(or QCircuit) the source prog(or circuit)\ @@ -1390,19 +1829,19 @@ PYBIND11_MODULE(pyQPanda, m) Merge_RZ : merge continues RZ gates\ * @return new prog\ * / ", - py::return_value_policy::automatic - ); + py::return_value_policy::automatic + ); - m.def("circuit_optimizer_by_config", [](QProg prog, const std::string config_data, + m.def("circuit_optimizer_by_config", [](QProg prog, const std::string config_data, const std::vector& mode_list) { int mode = 0; for (const auto& m : mode_list) { mode |= m; } - cir_optimizer_by_config(prog, config_data, mode); - return prog; - }, "prog"_a, "config_data"_a = CONFIG_PATH, "mode"_a = std::vector(0), - "/**\ + cir_optimizer_by_config(prog, config_data, mode); + return prog; + }, "prog"_a, "config_data"_a = CONFIG_PATH, "mode"_a = std::vector(0), + "/**\ * @brief QCircuit optimizer\ * @ingroup Utilities\ * @param[in, out] QProg(or QCircuit) the source prog(or circuit)\ @@ -1416,60 +1855,60 @@ PYBIND11_MODULE(pyQPanda, m) Merge_RZ : merge continues RZ gates\ * @return new prog\ * / ", - py::return_value_policy::automatic - ); - - m.def("get_all_used_qubits", [](QProg prog) { - QVec vec_qubits_in_use; - get_all_used_qubits(prog, vec_qubits_in_use); - return vec_qubits_in_use; - }, "qprog"_a, - "Get all the used quantum bits in the input prog", - py::return_value_policy::automatic - ); - - m.def("get_all_used_qubits_to_int", [](QProg prog) { - std::vector vec_qubits_in_use; - get_all_used_qubits(prog, vec_qubits_in_use); - return vec_qubits_in_use; - }, "qprog"_a, - "Get all the used quantum bits in the input prog, return all the index of qubits", - py::return_value_policy::automatic - ); - - m.def("state_fidelity", [](const QStat &state1, const QStat &state2) - { - return state_fidelity(state1, state2); - }, "state1"_a, "state2"_a, - "Get state fidelity", - py::return_value_policy::automatic - ); - - m.def("state_fidelity", [](const std::vector &matrix1, const std::vector &matrix2) - { - return state_fidelity(matrix1, matrix2); - }, "state1"_a, "state2"_a, - "Get state fidelity", - py::return_value_policy::automatic - ); - - m.def("state_fidelity", [](const QStat &state, const vector &matrix) - { - return state_fidelity(state, matrix); - }, "state1"_a, "state2"_a, - "Get state fidelity", - py::return_value_policy::automatic - ); - - m.def("state_fidelity", [](const vector &matrix, const QStat &state) - { - return state_fidelity(matrix, state); - }, "state1"_a, "state2"_a, - "Get state fidelity", - py::return_value_policy::automatic - ); - - m.def("get_circuit_optimal_topology", [](QProg& prog, QuantumMachine* quantum_machine, + py::return_value_policy::automatic + ); + + m.def("get_all_used_qubits", [](QProg prog) { + QVec vec_qubits_in_use; + get_all_used_qubits(prog, vec_qubits_in_use); + return vec_qubits_in_use; + }, "qprog"_a, + "Get all the used quantum bits in the input prog", + py::return_value_policy::automatic + ); + + m.def("get_all_used_qubits_to_int", [](QProg prog) { + std::vector vec_qubits_in_use; + get_all_used_qubits(prog, vec_qubits_in_use); + return vec_qubits_in_use; + }, "qprog"_a, + "Get all the used quantum bits in the input prog, return all the index of qubits", + py::return_value_policy::automatic + ); + + m.def("state_fidelity", [](const QStat &state1, const QStat &state2) + { + return state_fidelity(state1, state2); + }, "state1"_a, "state2"_a, + "Get state fidelity", + py::return_value_policy::automatic + ); + + m.def("state_fidelity", [](const std::vector &matrix1, const std::vector &matrix2) + { + return state_fidelity(matrix1, matrix2); + }, "state1"_a, "state2"_a, + "Get state fidelity", + py::return_value_policy::automatic + ); + + m.def("state_fidelity", [](const QStat &state, const vector &matrix) + { + return state_fidelity(state, matrix); + }, "state1"_a, "state2"_a, + "Get state fidelity", + py::return_value_policy::automatic + ); + + m.def("state_fidelity", [](const vector &matrix, const QStat &state) + { + return state_fidelity(matrix, state); + }, "state1"_a, "state2"_a, + "Get state fidelity", + py::return_value_policy::automatic + ); + + m.def("get_circuit_optimal_topology", [](QProg& prog, QuantumMachine* quantum_machine, const size_t max_connect_degree, const std::string config_data) { return get_circuit_optimal_topology(prog, quantum_machine, max_connect_degree, config_data); }, "prog"_a, "quantum_machine"_a, "max_connect_degree"_a, "config_data"_a = CONFIG_PATH, @@ -1477,55 +1916,55 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic ); - m.def("get_double_gate_block_topology", [](QProg& prog) { - return get_double_gate_block_topology(prog); - }, "prog"_a, - "get double gate block topology", - py::return_value_policy::automatic - ); - - m.def("del_weak_edge", [](TopologyData& topo_data) { - del_weak_edge(topo_data); - return topo_data; - }, "matrix"_a, - "Delete weakly connected edges", - py::return_value_policy::automatic - ); - - m.def("del_weak_edge2", [](TopologyData& topo_data, const size_t max_connect_degree, std::vector& sub_graph_set) { - py::list ret_data; - - std::vector candidate_edges; - std::vector intermediary_points = del_weak_edge(topo_data, max_connect_degree, sub_graph_set, candidate_edges); - - ret_data.append(topo_data); - ret_data.append(intermediary_points); - ret_data.append(candidate_edges); - return ret_data; - }, "matrix"_a, "int"_a, "list"_a, - "Delete weakly connected edges", - py::return_value_policy::automatic - ); - - m.def("del_weak_edge3", [](TopologyData& topo_data, std::vector& sub_graph_set, const size_t max_connect_degree, - const double lamda1, const double lamda2, const double lamda3) { - py::list ret_data; - - std::vector intermediary_points = del_weak_edge(topo_data, sub_graph_set, max_connect_degree, lamda1, lamda2, lamda3); - - ret_data.append(topo_data); - ret_data.append(intermediary_points); - return ret_data; - }, "matrix"_a, "list"_a, "int"_a, "data"_a, "data"_a, "data"_a, - "Delete weakly connected edges", - py::return_value_policy::automatic - ); - - m.def("recover_edges", [](TopologyData& topo_data, const size_t max_connect_degree, std::vector& candidate_edges) { - recover_edges(topo_data, max_connect_degree, candidate_edges); - return topo_data; - }, "matrix"_a, "int"_a, "list"_a, - "/**\ + m.def("get_double_gate_block_topology", [](QProg& prog) { + return get_double_gate_block_topology(prog); + }, "prog"_a, + "get double gate block topology", + py::return_value_policy::automatic + ); + + m.def("del_weak_edge", [](TopologyData& topo_data) { + del_weak_edge(topo_data); + return topo_data; + }, "matrix"_a, + "Delete weakly connected edges", + py::return_value_policy::automatic + ); + + m.def("del_weak_edge2", [](TopologyData& topo_data, const size_t max_connect_degree, std::vector& sub_graph_set) { + py::list ret_data; + + std::vector candidate_edges; + std::vector intermediary_points = del_weak_edge(topo_data, max_connect_degree, sub_graph_set, candidate_edges); + + ret_data.append(topo_data); + ret_data.append(intermediary_points); + ret_data.append(candidate_edges); + return ret_data; + }, "matrix"_a, "int"_a, "list"_a, + "Delete weakly connected edges", + py::return_value_policy::automatic + ); + + m.def("del_weak_edge3", [](TopologyData& topo_data, std::vector& sub_graph_set, const size_t max_connect_degree, + const double lamda1, const double lamda2, const double lamda3) { + py::list ret_data; + + std::vector intermediary_points = del_weak_edge(topo_data, sub_graph_set, max_connect_degree, lamda1, lamda2, lamda3); + + ret_data.append(topo_data); + ret_data.append(intermediary_points); + return ret_data; + }, "matrix"_a, "list"_a, "int"_a, "data"_a, "data"_a, "data"_a, + "Delete weakly connected edges", + py::return_value_policy::automatic + ); + + m.def("recover_edges", [](TopologyData& topo_data, const size_t max_connect_degree, std::vector& candidate_edges) { + recover_edges(topo_data, max_connect_degree, candidate_edges); + return topo_data; + }, "matrix"_a, "int"_a, "list"_a, + "/**\ * @brief Recover edges from the candidate edges\ * @ingroup Utilities\ * @param[in] const TopologyData& the target graph\ @@ -1533,102 +1972,102 @@ PYBIND11_MODULE(pyQPanda, m) * @param[in] std::vector& Thecandidate edges\ * @return\ * / ", - py::return_value_policy::automatic - ); - - m.def("get_complex_points", [](TopologyData& topo_data, const size_t max_connect_degree) { - return get_complex_points(topo_data, max_connect_degree); - }, "matrix"_a, "int"_a, - "Get complex points", - py::return_value_policy::automatic - ); - - m.def("split_complex_points", [](std::vector& complex_points, const size_t max_connect_degree, - const TopologyData& topo_data, int split_method = 0) { - return split_complex_points(complex_points, max_connect_degree, topo_data, static_cast(split_method)); - }, "data"_a, "int"_a, "matrix"_a, "int"_a = 0, - "Splitting complex points into multiple points", - py::return_value_policy::automatic - ); - - m.def("replace_complex_points", [](TopologyData& src_topo_data, const size_t max_connect_degree, - const std::vector>& sub_topo_vec) { - replace_complex_points(src_topo_data, max_connect_degree, sub_topo_vec); - return src_topo_data; - }, "matrix"_a, "int"_a, "data"_a, - "Replacing complex points with subgraphs", - py::return_value_policy::automatic - ); - - m.def("get_sub_graph", [](TopologyData& topo_data) { - return get_sub_graph(topo_data); - }, "matrix"_a, - "Get sub graph", - py::return_value_policy::automatic - ); - - m.def("estimate_topology", [](const TopologyData& topo_data) { - return estimate_topology(topo_data); - }, "matrix"_a, - "Evaluate topology performance", - py::return_value_policy::automatic - ); - - m.def("planarity_testing", [](const TopologyData& topo_data) { - return planarity_testing(topo_data); - }, "matrix"_a, - "/**\ + py::return_value_policy::automatic + ); + + m.def("get_complex_points", [](TopologyData& topo_data, const size_t max_connect_degree) { + return get_complex_points(topo_data, max_connect_degree); + }, "matrix"_a, "int"_a, + "Get complex points", + py::return_value_policy::automatic + ); + + m.def("split_complex_points", [](std::vector& complex_points, const size_t max_connect_degree, + const TopologyData& topo_data, int split_method = 0) { + return split_complex_points(complex_points, max_connect_degree, topo_data, static_cast(split_method)); + }, "data"_a, "int"_a, "matrix"_a, "int"_a = 0, + "Splitting complex points into multiple points", + py::return_value_policy::automatic + ); + + m.def("replace_complex_points", [](TopologyData& src_topo_data, const size_t max_connect_degree, + const std::vector>& sub_topo_vec) { + replace_complex_points(src_topo_data, max_connect_degree, sub_topo_vec); + return src_topo_data; + }, "matrix"_a, "int"_a, "data"_a, + "Replacing complex points with subgraphs", + py::return_value_policy::automatic + ); + + m.def("get_sub_graph", [](TopologyData& topo_data) { + return get_sub_graph(topo_data); + }, "matrix"_a, + "Get sub graph", + py::return_value_policy::automatic + ); + + m.def("estimate_topology", [](const TopologyData& topo_data) { + return estimate_topology(topo_data); + }, "matrix"_a, + "Evaluate topology performance", + py::return_value_policy::automatic + ); + + m.def("planarity_testing", [](const TopologyData& topo_data) { + return planarity_testing(topo_data); + }, "matrix"_a, + "/**\ * @brief planarity testing\ * @ingroup Utilities\ * @param[in] const TopologyData& the target graph\ * @return bool If the input graph is planarity, return true, otherwise retuen false.\ * / ", - py::return_value_policy::automatic - ); - - m.def("single_qubit_rb", [](NoiseQVM* qvm, Qubit* qbit, const std::vector& clifford_range, \ - int num_circuits, int shots, const std::vector& interleaved_gates) { - return single_qubit_rb(qvm, qbit, clifford_range, num_circuits, shots, interleaved_gates); - }, - py::arg("qvm"), py::arg("qbit"), py::arg("clifford_range"), - py::arg("num_circuits"), py::arg("shots"), py::arg("interleaved_gates") = std::vector(), + py::return_value_policy::automatic + ); + + m.def("single_qubit_rb", [](NoiseQVM* qvm, Qubit* qbit, const std::vector& clifford_range, \ + int num_circuits, int shots, const std::vector& interleaved_gates) { + return single_qubit_rb(qvm, qbit, clifford_range, num_circuits, shots, interleaved_gates); + }, + py::arg("qvm"), py::arg("qbit"), py::arg("clifford_range"), + py::arg("num_circuits"), py::arg("shots"), py::arg("interleaved_gates") = std::vector(), "single qubit rb with noise quantum virtual machine", py::return_value_policy::automatic ); - m.def("double_qubit_rb", [](NoiseQVM* qvm, Qubit* qbit0, Qubit* qbit1, const std::vector& clifford_range, \ - int num_circuits, int shots, const std::vector& interleaved_gates) { - return double_qubit_rb(qvm, qbit0, qbit1, clifford_range, num_circuits, shots, interleaved_gates); - }, - py::arg("qvm"), py::arg("qbit0"), py::arg("qbit1"), py::arg("clifford_range"), - py::arg("num_circuits"), py::arg("shots"), py::arg("interleaved_gates") = std::vector(), + m.def("double_qubit_rb", [](NoiseQVM* qvm, Qubit* qbit0, Qubit* qbit1, const std::vector& clifford_range, \ + int num_circuits, int shots, const std::vector& interleaved_gates) { + return double_qubit_rb(qvm, qbit0, qbit1, clifford_range, num_circuits, shots, interleaved_gates); + }, + py::arg("qvm"), py::arg("qbit0"), py::arg("qbit1"), py::arg("clifford_range"), + py::arg("num_circuits"), py::arg("shots"), py::arg("interleaved_gates") = std::vector(), "double qubit rb with noise quantum virtual machine", py::return_value_policy::automatic - ); + ); m.def("single_qubit_rb", [](QCloudMachine* qvm, Qubit* qbit, const std::vector& clifford_range, \ - int num_circuits, int shots, const std::vector& interleaved_gates ) { + int num_circuits, int shots, const std::vector& interleaved_gates) { return single_qubit_rb(qvm, qbit, clifford_range, num_circuits, shots, interleaved_gates); - }, + }, py::arg("qvm"), py::arg("qbit"), py::arg("clifford_range"), py::arg("num_circuits"), py::arg("shots"), py::arg("interleaved_gates") = std::vector(), "single qubit rb with WU YUAN chip", py::return_value_policy::automatic - ); + ); m.def("double_qubit_rb", [](QCloudMachine* qvm, Qubit* qbit0, Qubit* qbit1, const std::vector& clifford_range, \ - int num_circuits, int shots, const std::vector& interleaved_gates) { + int num_circuits, int shots, const std::vector& interleaved_gates) { return double_qubit_rb(qvm, qbit0, qbit1, clifford_range, num_circuits, shots, interleaved_gates); - }, + }, py::arg("qvm"), py::arg("qbit0"), py::arg("qbit1"), py::arg("clifford_range"), py::arg("num_circuits"), py::arg("shots"), py::arg("interleaved_gates") = std::vector(), "double qubit rb with WU YUAN chip", py::return_value_policy::automatic - ); + ); - m.def("double_gate_xeb", [](QCloudMachine* qvm, Qubit* qbit0, Qubit* qbit1, const std::vector& clifford_range, \ + m.def("double_gate_xeb", [](QCloudMachine* qvm, Qubit* qbit0, Qubit* qbit1, const std::vector& clifford_range, \ int num_circuits, int shots, GateType gt = GateType::CZ_GATE) { return double_gate_xeb(qvm, qbit0, qbit1, clifford_range, num_circuits, shots, gt); }, "cloud_qvm"_a, @@ -1657,7 +2096,7 @@ PYBIND11_MODULE(pyQPanda, m) ); m.def("calculate_quantum_volume", [](NoiseQVM* qvm, std::vector >qubit_lists, \ - int ntrials, int shots = 1000) { + int ntrials, int shots = 1000) { return calculate_quantum_volume(qvm, qubit_lists, ntrials, shots); }, "noise_qvm"_a, "qubit lists"_a, @@ -1678,21 +2117,21 @@ PYBIND11_MODULE(pyQPanda, m) py::return_value_policy::automatic ); - /* =============================test end =============================*/ + /* =============================test end =============================*/ - /*QUERY_REPLACE(QProg, QCircuit, QCircuit) - QUERY_REPLACE(QProg, QCircuit, QGate) - QUERY_REPLACE(QProg, QGate, QCircuit) - QUERY_REPLACE(QProg, QGate, QGate) + /*QUERY_REPLACE(QProg, QCircuit, QCircuit) + QUERY_REPLACE(QProg, QCircuit, QGate) + QUERY_REPLACE(QProg, QGate, QCircuit) + QUERY_REPLACE(QProg, QGate, QGate) - QUERY_REPLACE(QCircuit, QCircuit, QCircuit) - QUERY_REPLACE(QCircuit, QCircuit, QGate) - QUERY_REPLACE(QCircuit, QGate, QCircuit) - QUERY_REPLACE(QCircuit, QGate, QGate) + QUERY_REPLACE(QCircuit, QCircuit, QCircuit) + QUERY_REPLACE(QCircuit, QCircuit, QGate) + QUERY_REPLACE(QCircuit, QGate, QCircuit) + QUERY_REPLACE(QCircuit, QGate, QGate) - QUERY_REPLACE(QGate, QCircuit, QCircuit) - QUERY_REPLACE(QGate, QCircuit, QGate) - QUERY_REPLACE(QGate, QGate, QCircuit) - QUERY_REPLACE(QGate, QGate, QGate);*/ + QUERY_REPLACE(QGate, QCircuit, QCircuit) + QUERY_REPLACE(QGate, QCircuit, QGate) + QUERY_REPLACE(QGate, QGate, QCircuit) + QUERY_REPLACE(QGate, QGate, QGate);*/ }