conda create -n qpanda python=3.8
conda activate qpanda
python -m pip install pyqpanda
python -c "import pyqpanda"

/home/erina/build/QPanda-2/Core/VirtualQuantumProcessor/SparesQVM/SparseQVM.cpp: In member function ‘void QPanda::SparseSimulator::SWAP(size_t, size_t)’:
/home/erina/build/QPanda-2/Core/VirtualQuantumProcessor/SparesQVM/SparseQVM.cpp:817:14: error: no matching function for call to ‘swap(std::vector<bool>::reference, std::vector<bool>::reference)’
  817 |     std::swap(_queue_Ry[index_1], _queue_Ry[index_2]);
      |     ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/12/include/g++-v12/bits/new_allocator.h:36,
                 from /usr/lib/gcc/x86_64-pc-linux-gnu/12/include/g++-v12/x86_64-pc-linux-gnu/bits/c++allocator.h:33,
                 from /usr/lib/gcc/x86_64-pc-linux-gnu/12/include/g++-v12/bits/allocator.h:46,
                 from /usr/lib/gcc/x86_64-pc-linux-gnu/12/include/g++-v12/string:41,
                 from /home/erina/build/QPanda-2/include/Core/VirtualQuantumProcessor/SparseQVM/SparseQVM.h:4,
                 from /home/erina/build/QPanda-2/Core/VirtualQuantumProcessor/SparesQVM/SparseQVM.cpp:1:
/usr/lib/gcc/x86_64-pc-linux-gnu/12/include/g++-v12/bits/move.h:196:5: note: candidate: ‘std::_Require<std::__not_<std::__is_tuple_like<_Tp> >, std::is_move_constructible<_Tp>, std::is_move_assignable<_Tp> > std::swap(_Tp&, _Tp&) [with _Tp = _Bit_reference; _Require<__not_<__is_tuple_like<_Tp> >, is_move_constructible<_Tp>, is_move_assignable<_Tp> > = void]’ (near match)
  196 |     swap(_Tp& __a, _Tp& __b)
      |     ^~~~
/usr/lib/gcc/x86_64-pc-linux-gnu/12/include/g++-v12/bits/move.h:196:5: note:   conversion of argument 2 would be ill-formed:
/home/erina/build/QPanda-2/Core/VirtualQuantumProcessor/SparesQVM/SparseQVM.cpp:817:52: error: cannot bind non-const lvalue reference of type ‘std::_Bit_reference&’ to an rvalue of type ‘std::vector<bool>::reference’
  817 |     std::swap(_queue_Ry[index_1], _queue_Ry[index_2]);
      |                                   ~~~~~~~~~~~~~~~~~^
/usr/lib/gcc/x86_64-pc-linux-gnu/12/include/g++-v12/bits/move.h:220:5: note: candidate: ‘template<class _Tp, long unsigned int _Nm> std::__enable_if_t<std::__is_swappable<_Tp>::value> std::swap(_Tp (&)[_Nm], _Tp (&)[_Nm])’
  220 |     swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
      |     ^~~~

(A lot of lines truncated, most of them indicating errors about the swap function)

$ cmake -DCMAKE_INSTALL_PREFIX=/usr/local .. 
-- QPANDA VERSION = [1.3.3]
-- :  No build type selected, default is Release
CUDA_TOOLKIT_ROOT_DIR not found or specified
-- Could NOT find CUDA (missing: CUDA_TOOLKIT_ROOT_DIR CUDA_NVCC_EXECUTABLE CUDA_INCLUDE_DIRS CUDA_CUDART_LIBRARY) 
-- Found OpenMP_C: -fopenmp  
-- Found OpenMP_CXX: -fopenmp  
-- Found OpenMP: TRUE   
OPENMP FOUND
-- Could NOT find CURL (missing: CURL_LIBRARY CURL_INCLUDE_DIR) 
-- Could NOT find MPI_C (missing: MPI_C_LIB_NAMES MPI_C_HEADER_DIR MPI_C_WORKS) 
-- Could NOT find MPI_CXX (missing: MPI_CXX_LIB_NAMES MPI_CXX_HEADER_DIR MPI_CXX_WORKS) 
-- Could NOT find MPI (missing: MPI_C_FOUND MPI_CXX_FOUND) 
-- Could NOT find PythonLibs (missing: PYTHON_LIBRARIES PYTHON_INCLUDE_DIRS) (Required is at least version "3")


CMake Warning at CMakeLists.txt:193 (message):
  CUDA is not found, GPUQVM is unuseable !!!


CMake Warning at CMakeLists.txt:196 (message):
  Curl is not found, CloudHTTP is unuseable !!!


CMake Error: The following variables are used in this project, but they are set to NOTFOUND.
Please set them or make sure they are set and tested correctly in the CMake files:
PYTHON_LIBRARY (ADVANCED)
    linked by target "pyQPanda" in directory /home/it2911/IdeaProjects/github/OriginQ/QPanda-2/pyQPandaCpp/pyQPanda.Core
    linked by target "pyQPandaPauliOperator" in directory /home/it2911/IdeaProjects/github/OriginQ/QPanda-2/pyQPandaCpp/pyQPanda.PauliOperator

-- Configuring incomplete, errors occurred!
See also "/home/it2911/IdeaProjects/github/OriginQ/QPanda-2/build/CMakeFiles/CMakeOutput.log".

cmake_minimum_required(VERSION 3.1)
#设置项目名称
project(testQPanda)
# 定义自己的 cmake 模块所在的路径
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${QPANDA_INSTALL_DIR}/lib/cmake")
#指定C++版本
set(CMAKE_CXX_STANDARD 14)

#设置 C++ 编译选项
add_definitions("-w -DGTEST_USE_OWN_TR1_TUPLE=1")
set(CMAKE_BUILD_TYPE "Release")
set(CMAKE_CXX_FLAGS_DEBUG "$ENV{CXXFLAGS} -O0 -g -ggdb")
set(CMAKE_CXX_FLAGS_RELEASE "$ENV{CXXFLAGS} -O3")
add_compile_options(-fpermissive)

#重新定义目标链接库文件的存放位置
set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)
#重新定义目标二进制可执行文件的存放位置
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
#引入外部依赖包
list(APPEND CMAKE_PREFIX_PATH /usr/local/)
find_package(QPANDA REQUIRED)

# set(CURL_LIBRARY "-lcurl")
# find_package(CURL REQUIRED)

include_directories(${QPANDA_INCLUDE_DIR})
# 生成可执行文件
add_executable(${PROJECT_NAME} example.cpp)
target_link_libraries(${PROJECT_NAME} ${QPANDA_LIBRARIES})

/usr/bin/ld: /usr/local/lib/libQPanda2.a(QCloudMachine.cpp.o): in function `QPanda::QCloudMachine::~QCloudMachine()':
QCloudMachine.cpp:(.text+0x2a6a): undefined reference to `curl_global_cleanup'
/usr/bin/ld: /usr/local/lib/libQPanda2.a(QCloudMachine.cpp.o): in function `QPanda::QCloudMachine::QCloudMachine()':
QCloudMachine.cpp:(.text+0x3083): undefined reference to `curl_global_init'
/usr/bin/ld: /usr/local/lib/libQPanda2.a(QCloudMachine.cpp.o): in function `QPanda::QCloudMachine::post_json(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&)':
QCloudMachine.cpp:(.text+0x3963): undefined reference to `curl_easy_init'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x3974): undefined reference to `curl_slist_append'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x3983): undefined reference to `curl_slist_append'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x3992): undefined reference to `curl_slist_append'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x39a1): undefined reference to `curl_slist_append'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x39b0): undefined reference to `curl_slist_append'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x39c5): undefined reference to `curl_easy_setopt'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x39d9): undefined reference to `curl_easy_setopt'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x39ea): undefined reference to `curl_easy_setopt'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x39fc): undefined reference to `curl_easy_setopt'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x3a10): undefined reference to `curl_easy_setopt'
/usr/bin/ld: /usr/local/lib/libQPanda2.a(QCloudMachine.cpp.o):QCloudMachine.cpp:(.text+0x3a24): more undefined references to `curl_easy_setopt' follow
/usr/bin/ld: /usr/local/lib/libQPanda2.a(QCloudMachine.cpp.o): in function `QPanda::QCloudMachine::post_json(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&)':
QCloudMachine.cpp:(.text+0x3ac0): undefined reference to `curl_easy_perform'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x3ad3): undefined reference to `curl_slist_free_all'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x3adb): undefined reference to `curl_easy_cleanup'
/usr/bin/ld: QCloudMachine.cpp:(.text+0x3e58): undefined reference to `curl_easy_strerror'
collect2: error: ld returned 1 exit status
make[2]: *** [CMakeFiles/testQPanda.dir/build.make:102: bin/testQPanda] Error 1
make[1]: *** [CMakeFiles/Makefile2:83: CMakeFiles/testQPanda.dir/all] Error 2
make: *** [Makefile:91: all] Error 2

def soft_max(a):
    softmax = []
    softmax_total = 0
    for i in range(10):
         softmax_total = softmax_total + vexp(a[i])
    for i in range(10):
             softmax.append(vexp(a[i]))
        return softmax

def soft_max(a):
    softmax_total = 0
    for i in range(10):
        softmax_total += vexp(a[i])
return vexp(a)/softmax_total

/usr/local/lib/python3.11/site-packages/pyqpanda-3.7.17-py3.11.egg/pyqpanda/__init__.py:26: UserWarning: No module named QCloud
  warnings.warn("No module named QCloud")

from pyqpanda import *
# init(QMachineType.CPU)
prog = QProg()
draw_qprog(prog)

eval(a[2], True) √ [[0.3]]

eval(a[1], True)  [[0.1]]
eval(a[2], True) × 

eval(a, True) √ [[0.1], [0.2], [0.3]]

eval(sum(a), True) √ [[0.6]]

eval(a ,True)[2] √ [0.3]

eval(b, True) ×

from pyqpanda import *
from pyqpanda import exp as vexp
from pyqpanda import log as vlog
from scipy.optimize import minimize
from functools import partial
from matplotlib.pyplot import *
import sklearn.datasets as datasets
import numpy as np
import random
import math
import copy
import time

p = 0
MAX_ROW = 4
MAX_COLUMN = 4

class state:
    def __init__(self, row, column):
        self.r = row
        self.c = column
    def __eq__(self, other):
        if(self.r == other.r and self.c == other.c):
            return True
        else:
            return False
class rstate(state):
    def __init__(self, row, column, reward):
        state.__init__(self, row, column)
        self.rw = reward

terminalset = [state(3, 3)]
abyssset = [state(0, 3), state(1, 1), state(1, 2), state(2, 1), state(2, 2)]

def reward(currentstate):
    if currentstate in terminalset:
        return 1
    elif currentstate in abyssset:
        return -1
    else:
        return 0

def end_or_not(currentstate):
    if (currentstate in terminalset) or (currentstate in abyssset):
        return True
    else:
        return False


def epsilon_greedy(currentstate, epsilon, Q):
    global MAX_ROW
    global MAX_COLUMN
    global rewardset
    choice = 0
    ran = np.random.random()
    if(ran < epsilon):
        choice = np.random.permutation(4)[0]
    else:
        set = []
        for i in range(4):
            set.append({'order': i + 1, 'value': Q[i]})
        np.random.shuffle(set)
        choice = max(set, key=lambda x: x['value'])['order']
    if(choice == 1 and currentstate.r > 0):
        nextstate = state(currentstate.r - 1, currentstate.c)
    elif(choice == 2 and currentstate.c < MAX_COLUMN - 1):
        nextstate = state(currentstate.r, currentstate.c + 1)
    elif(choice == 3 and currentstate.r < MAX_ROW - 1):
        nextstate = state(currentstate.r + 1, currentstate.c)
    elif(choice == 4 and currentstate.c > 0):
        nextstate = state(currentstate.r, currentstate.c - 1) 
    else:
        nextstate = state(currentstate.r, currentstate.c)  
    return nextstate, choice

def new_experience(exp_set, currentstate, nextstate, choice):
    reward_value = reward(nextstate)
    end_or_not_value = end_or_not(nextstate)
    exp_set.append([currentstate, nextstate, reward_value, end_or_not_value, choice])

def sample_from_exp_set(exp_set, num):
    if len(exp_set) <= num:
        sample_set = exp_set
    else:
        sample_set = random.sample(exp_set, num)
    return sample_set

def initial_state(qubitlist, currentstate):
    vqc = VariationalQuantumCircuit()
    bi_str = bin(currentstate.r + 4)[3:] + bin(currentstate.c + 4)[3:] 
    for i in range(len(bi_str)):
        # a = math.pi * int(bi_str[i]) 
        vqc.insert(VariationalQuantumGate_RY(qubitlist[i], var(math.pi * int(bi_str[i]))))
    return vqc

def unitary_local(qubitlist, theta_y, theta_z):
    vqc = VariationalQuantumCircuit()
    for i in range(len(qubitlist)):
        vqc.insert(VariationalQuantumGate_RY(qubitlist[i], theta_y[i])) \
           .insert(VariationalQuantumGate_RZ(qubitlist[i], theta_z[i])) 
    return vqc

def unitary_entangling(qubitlist):
    vqc = VariationalQuantumCircuit()
    for i in range(len(qubitlist) - 1):
        vqc.insert(VariationalQuantumGate_CZ(qubitlist[i], qubitlist[i + 1]))
    vqc.insert(VariationalQuantumGate_CZ(qubitlist[0], qubitlist[len(qubitlist) - 1]))
    return vqc

def classifier_circuit(qubitlist, currentstate, depth, theta_y, theta_z):
    vqc = VariationalQuantumCircuit()
    vqc.insert(initial_state(qubitlist, currentstate)) \
       .insert(unitary_local(qubitlist, theta_y[0], theta_z[0])) 
    for i in range(1, depth):
        vqc.insert(unitary_entangling(qubitlist)) \
           .insert(unitary_local(qubitlist, theta_y[i], theta_z[i]))
    return vqc

def q_meas(vqc, Z_str, machine, qubitlist):
    expection_v = qop(vqc, PauliOperator({Z_str : 1}), machine, qubitlist)
    return expection_v


def Q_2(sample, gamma, qubit_num, depth, theta_y, theta_z, machine):
    if sample[3] == True:
        Q = sample[2]
    else:
        qubitlist_2 = machine.qAlloc_many(qubit_num)
        vqc_2 = classifier_circuit(qubitlist_2, sample[1], depth, theta_y, theta_z)
        expection_set = []
        for i in range(4):
            Z_str = 'Z' + str(i)
            expection_v = q_meas(vqc_2, Z_str, machine, qubitlist_2)
            expection_c = eval(expection_v, True)
            expection_set.append(expection_c[0][0])
        machine.qFree_all(qubitlist_2)
        Q_set = expection_set
        np.random.shuffle(Q_set)
        Q = sample[2] + gamma * max(Q_set)
    return Q

def naturedqn(qubit_num, depth, epsilon):
    count = 1
    gamma = 0.9
    # epsilon = 0.1
    t = 20
    sample_num = 5
    learning_rate = 0.3
    coefficient = 0.9
    period = 5
    exp_set = []
    theta_y = 2 * math.pi * np.random.random((depth, qubit_num))
    theta_z = 2 * math.pi * np.random.random((depth, qubit_num))
    theta_y_2 = theta_y
    theta_z_2 = theta_z
    theta_y_3 = theta_y
    theta_z_3 = theta_z
    machine = init_quantum_machine(QMachineType.CPU_SINGLE_THREAD)
    for i in range(t):
        currentstate = state(0, 0)
        while not ((currentstate in terminalset) or (currentstate in abyssset)):
            theta_y_3_v = var(theta_y_3)
            theta_z_3_v = var(theta_z_3)
            qubitlist_3 = machine.qAlloc_many(qubit_num)
            vqc_3 = classifier_circuit(qubitlist_3, currentstate, depth, theta_y_3_v, theta_z_3_v)
            expection_set = []
            for i in range(4):
                Z_str = 'Z' + str(i)
                expection_v = q_meas(vqc_3, Z_str, machine, qubitlist_3)
                expection_c = eval(expection_v, True)
                expection_set.append(expection_c[0][0])
            machine.qFree_all(qubitlist_3)
            Q_set = expection_set
            nextstate, choice = epsilon_greedy(currentstate, epsilon, Q_set)
            new_experience(exp_set, currentstate, nextstate, choice)
            currentstate = nextstate

            sample_set = sample_from_exp_set(exp_set, sample_num)
            theta_y_v = var(theta_y)
            theta_z_v = var(theta_z)
            theta_y_2_v = var(theta_y_2)
            theta_z_2_v = var(theta_z_2)
            grad = {theta_y_v : np.zeros((depth, qubit_num)), theta_z_v : np.zeros((depth, qubit_num))}
            velocity = {theta_y_v : np.zeros((depth, qubit_num)), theta_z_v : np.zeros((depth, qubit_num))} 

            Q1_set = []
            Q2_set = []
            loss_v = var(0)
            qubitlist = machine.qAlloc_many(qubit_num)

            for j in range(len(sample_set)):
                vqc = classifier_circuit(qubitlist, sample_set[j][0], depth, theta_y_v, theta_z_v)
                Z_str = 'Z' + str(sample_set[j][4] - 1)
                Q1_set.append(q_meas(vqc, Z_str, machine, qubitlist))
                Q2_set.append(Q_2(sample_set[j], gamma, qubit_num, depth, theta_y_2_v, theta_z_2_v, machine))
            for j in range(len(sample_set)):
                loss_v = loss_v + (Q1_set[j] - Q2_set[j]) * (Q1_set[j] - Q2_set[j])
            loss_v = loss_v / len(sample_set)
            loss_c = eval(loss_v, True)
            print(count,':', loss_c)
            count += 1
            back(expression(loss_v), grad)
            # print(grad)

            for variable in grad:
                raw_value = variable.get_value()
                velocity[variable] = - grad[variable] * learning_rate + velocity[variable] * coefficient
                new_value =  raw_value + velocity[variable]
                variable.set_value(new_value)
            theta_y = eval(theta_y_v, True)
            theta_z = eval(theta_z_v, True)
            theta_y_3 = theta_y
            theta_z_3 = theta_z
            del grad
            del velocity
            if i % period == 0:
                theta_y_2 = theta_y
                theta_z_2 = theta_z
            machine.qFree_all(qubitlist)
        print(theta_y)
        print(theta_z)
    destroy_quantum_machine(machine)
    return theta_y, theta_z

def strategy(currentstate, qubit_num, depth, epsilon, theta_y, theta_z):
    machine = init_quantum_machine(QMachineType.CPU_SINGLE_THREAD)
    qubitlist = machine.qAlloc_many(qubit_num)
    machine = init_quantum_machine(QMachineType.CPU_SINGLE_THREAD)
    qubitlist = machine.qAlloc_many(qubit_num)
    vqc = classifier_circuit(qubitlist, currentstate, depth, var(theta_y), var(theta_z))
    expection_set = []
    for i in range(4):
        Z_str = 'Z' + str(i)
        expection_v = q_meas(vqc, Z_str, machine, qubitlist)
        expection_c = eval(expection_v, True)
        expection_set.append(expection_c)
    machine.qFree_all(qubitlist)
    destroy_quantum_machine(machine)
    Q_set = expection_set
    nextstate, choice = epsilon_greedy(currentstate, epsilon, Q_set)
    machine.qFree_all(qubitlist)
    destroy_quantum_machine(machine)
    return nextstate


qubit_num = 4
depth = 8
epsilon = 0.1
theta_y, theta_z = naturedqn(qubit_num, depth, epsilon)
test_state_set = [state(0,0), state(1,0), state(2,0), state(3,0), state(3,1), state(3,2), state(1,3)]
for i in range(len(test_state_set)):
    nextstate = strategy(test_state_set[i], qubit_num, depth, epsilon, theta_y, theta_z)
    print([test_state_set[i].r, test_state_set[i].c], ':', [nextstate.r, nextstate.c])

import pyqpanda.pyQPanda as pq
from pyqpanda import *
init(QMachineType.CPU)
q= qAlloc_many(2)
c = cAlloc_many(2)
prog = QProg()
prog.insert( X(q[0]) )
prog.insert(Measure(q[0], c[0]))
prog.insert(Measure(q[1], c[1]))
pq.draw_qprog(prog)
result = run_with_configuration(prog, cbit_list = c, shots = 1000)
print(result)

machine.set_qcloud_api("https://qcloud.originqc.com");

auto qlist = machine.allocateQubits(4);
auto clist = machine.allocateCBits(4);
auto measure_prog = QProg();
measure_prog << HadamardQCircuit(qlist)
    << CZ(qlist[2], qlist[3])
    << Measure(qlist[0], clist[0]);

auto pmeasure_prog = QProg();
pmeasure_prog << HadamardQCircuit(qlist)
    << CZ(qlist[1], qlist[3])
    << RX(qlist[2], PI / 4)
    << RX(qlist[1], PI / 4);

auto result0 = machine.full_amplitude_measure(measure_prog, 100);

Looking in indexes: https://mirrors.ustc.edu.cn/pypi/web/simple
ERROR: Could not find a version that satisfies the requirement pyqpanda (from versions: none)
ERROR: No matching distribution found for pyqpanda

allocateQubits qubitNumber > maxQubit