QPanda 2

一种功能齐全，运行高效的量子软件开发工具包

QPanda 2是由本源量子开发的开源量子计算框架，它可以用于构建、运行和优化量子算法。QPanda 2作为本源量子计算系列软件的基础库，为OriginIR、Qurator、量子计算服务提供核心部件。

为了方便用户使用，QPanda 2为用户提供了Python版本的pyQPanda,详情请参考 pyQPanda使用文档 。

下载、编译、安装和使用

下载QPanda-2

您可以通过以下途径获取QPanda2：

GitHub

1. 如果您已经在系统中安装了git， 您可以通过git来获取QPanda2：

• 选择一个保存QPanda2的文件夹，然后在文件夹内单击 鼠标右键 -Git Bash Here

• 在弹出的窗口中输入以下命令，再按下 Enter 键，然后静待下载完成即可：

git clone https://github.com/OriginQ/QPanda-2.git

2.当然了，对于一些未安装git的小伙伴来说，也可以直接通过浏览器去下载QPanda-2， 具体的操作步骤如下：

• 在浏览器中输入： https://github.com/OriginQ/QPanda-2 ， 进入网页会看到：

• 点击 Code 看到如下界面：

• 然后点击 Download ZIP， 就会完成QPanda2的下载。

Gitee

1. 同 GitHub ，如果在您的系统上已经安装了git，您只需要将输入变成以下命令即可：

git clone https://gitee.com/OriginQ/QPanda-2.git

2. 直接通过浏览器下载QPanda-2， 具体的操作步骤与 GitHub 类似。

在浏览器中输入 https://gitee.com/OriginQ/QPanda-2?_from=gitee_search ，打开后，依次单击 克隆/下载 - 下载ZIP 即可开始下载QPanda2。

编译和安装

在编译QPanda2之前，可以先了解一下QPanda2的可配置项：

1. FIND_CUDA : 查询系统中是否有cuda库，如果有就会将其编译进去， 在做量子计算时可以选择GPU作为计算后端

2. USE_CHEMIQ : 化学模拟库

3. USE_PYQPANDA : 编译出供python使用的pyqpanda库

默认情况下，上述的配置项都是关闭的，如果有需要，可以在编译时选择打开

Note

如需使用本源量子云服务，请在安装QPanda之前下载安装 curl库 。

Windows

在Windows平台下，QPanda-2支持使用Visual Studio和MinGW编译、安装。

Visual Studio

编译

这里以Visual Studio 2017为例，使用Visual Studio 2017 编译QPanda-2,只需要安装Visual Studio 2017， 并需要在组件中安装CMake组件。安装完成之后，用Visual Studio 2017打开QPanda-2文件夹。

首先，要选择x64-Release的模式下编译，按下面的提示选择：

然后, 选择更改cmake设置，查看有没有需要修改的配置项，如下:

进入cmake设置后可以看到，在默认情况下，FIND_CUDA、USE_CHEMIQ、USE_PYQPANDA 都是关闭的，如果有需要可以将对应的选项中的 OFF 修改为 ON

然后，点击 CMAKE选项中的 全部生成

可以看到:

等待一会，就会完成编译。

安装

在QPanda-2编译完成后，用户可以安装QPanda-2，Visual Studio 2017的安装方式很简单，只需要在cmake菜单中选择安装即可。

MinGW

编译

使用MinGW编译QPanda-2，需要自行搭建CMake和MinGW环境，用户可自行在网上查询环境搭建教程。（注意： MinGW需要安装64位版本）

CMake+MinGW的编译命令如下：

1. 在QPanda-2根目录下创建build文件夹

2. 进入build文件夹，可以按住 Shift + 鼠标右键 ，然后选择 在此处打开命令窗口(w) 或 在此处打开PowerShell窗口(s) 快捷打开cmd或PowerShell。

3. 输入下面的命令：

cmake -G"MinGW Makefiles" -DCMAKE_INSTALL_PREFIX=C:/QPanda2 -DFIND_CUDA=OFF -DUSE_CHEMIQ=OFF -DUSE_PYQPANDA=OFF ..
mingw32-make

也可以根据需要，将一些可配置项设置为 ON。

Warning

MinGW在支持cuda有还存在一些问题，因此使用MinGW不能将 DFIND_CUDA 设置为 ON 。

安装

在QPanda-2编译完成后，用户可以安装QPanda-2，安装命令如下：

mingw32-make install

Linux 和 MacOS

环境要求

• gcc/clang/（其它C++编译器）：支持C++14标准以及OpenMP

• CMake 3.0 以上

• pkg-config工具(Linux,必须。Ubuntu下使用 sudo apt-get install pkg-config 安装,CentOS下需要下载源码编译)

• UUID库（Linux，必须。Ubuntu下使用 sudo apt-get install uuid-dev 安装，CentOS下使用yum install libuuid-devel安装）

• Python 3.5 以上 (pyQPanda，可选)

• CURL (量子云连接功能，可选)

• MPI (在集群上运行量子虚拟机，可选)

• CUDA 9 以上 (在GPU上运行量子虚拟机，可选)

编译

1. 进入QPanda-2根目录

2. 输入以下命令：

mkdir -p build
cd build
cmake -DFIND_CUDA=OFF -DUSE_CHEMIQ=OFF -DUSE_PYQPANDA=OFF ..
make

如果有需求，用户通过命令修改QPanda-2的安装路径，配置方法如下所示：

mkdir -p build
cd build
cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DFIND_CUDA=OFF -DUSE_CHEMIQ=OFF -DUSE_PYQPANDA=OFF ..
make

也可以根据需求将可配置项设置为 ON

安装

在Linux和MacOS下安装命令QPanda-2，命令是一样的，安装命令如下：

sudo make install

Note

如果想使用pyqpanda也可以通过 pip install pyqpanda 命令直接下载我们发布的库，可以避免由于系统中的环境配置有问题导致pyqpanda编译出错的问题。

本文档中QPanda2安装目录：

• Windows下为：C:\QPanda2\

• Linux下为：/usr/local

• MacOS下为：/usr/local

使用

我们接下来通过一个示例介绍QPanda-2的使用，下面的例子可以在量子计算机中构建量子纠缠态(|00>+|11>)，对其进行测量，重复制备1000次。 预期的结果是约有50%的概率使测量结果分别在00或11上。

#include "QPanda.h"
USING_QPANDA

int main()
{
    // 初始化量子虚拟机
    init(QMachineType::CPU);

    // 申请量子比特以及经典寄存器
    auto q = qAllocMany(2);
    auto c = cAllocMany(2);

    // 构建量子程序
    QProg prog;
    prog << H(q[0])
        << CNOT(q[0],q[1])
        << MeasureAll(q, c);

    // 量子程序运行1000次，并返回测量结果
    auto results = runWithConfiguration(prog, c, 1000);

    // 打印量子态在量子程序多次运行结果中出现的次数
    for (auto &val: results)
    {
        std::cout << val.first << ", " << val.second << std::endl;
    }

    // 释放量子虚拟机
    finalize();

    return 0;
}

计算结果如下所示：

00 : 493
11 : 507

示例程序的编译方式与编译QPanda库的方式基本类似。我们在QPanda-2的github库中添加了 Template 文件夹，用于展示各个平台的使用案例。

下面将简单介绍一下QPanda2在Windows、linux、MacOS下的使用教程：

Windows

Visual Studio

visual studio 2017 下链接QPanda库需要配置QPanda的头文件地址和QPanda库的地址，下面以GateTypeValidator项目为例：

1. 选择中GateTypeValidator项目,右键选中属性。

2. 在设置visual studio 2017项目属性时，一定要注意配置管理器中的Release和Debug、及x64要与项目所选的相同（QPanda2不支持x86平台）。

3. 设置附加包含目录，选中C/C++ -> 所有选项 -> 附加包含目录，设置两个路径：${QPanda的安装路径}/include/qpanda2;${QPanda的安装路径}/include/qpanda2/ThirdParty

如果使用的QPanda2库是包含GPU计算部分的时候还需要添加cuda头文件的安装路径，设置的路径为：${QPanda的安装路径}/include/qpanda2;${QPanda的安装路径}/include/qpanda2/ThirdParty;${CUDA库的路径}/include

4. 设置运行库, 选中C/C++ -> 所有选项 -> 运行库，设置为MT

5. 设置库目录 ,选中链接器 -> 常规 -> 附加库目录，只需要设置lib路径卫：${QPanda的安装路径}/lib

如果使用的QPanda2库是包含GPU计算部分的时候还需要添加cuda库的安装路径，设置的路径为：${QPanda的安装路径}/lib;${CUDA库的路径}/lib/x64

6. 设置附加依赖项,选中链接器 -> 输入 -> 附加依赖项，设置以下依赖库：antlr4.lib;Components.lib;QAlg.lib;QPanda2.lib

包含GPU计算方式还需要添加下面两个库： GPUQGates.lib;cudart.lib

7. 设置符合模式，选中C/C++- > 语言 -> 符合模式，设置为否

Note

按照上述操作完成后，如若报错：LNK2001，可尝试以下操作：

选中C/C++- > 所有选项 -> 预处理器定义，删除 _DEBUG; ：

MinGW

1. 可以使用如下命令编译：

g++ test.cpp -std=c++14 -fopenmp -I{QPanda安装路径}/include/qpanda2/ -I{QPanda安装路径}/include/qpanda2/ThirdParty/ -L{QPanda安装路径}/lib/ -lQPanda2 -lantlr4 -o test

示例运行结果如下：

2. 也可以使用MinGW+CMake使用如下命令编译：

cd test
mkdir -p build
cd build
cmake -G"MinGW Makefiles" -DQPANDA_INSTALL_DIR=C:/QPanda2/ ..
mingw32-make

CMakelists配置为:

#指定 cmake 的最小版本
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)
#引入外部依赖包
find_package(QPANDA REQUIRED)
include_directories(${QPANDA_INCLUDE_DIR})
# 生成可执行文件
add_executable(${PROJECT_NAME} test.cpp)
target_link_libraries(${PROJECT_NAME} ${QPANDA_LIBRARIES})

CMake

可以使用CMake的方式调用QPanda2库编译生成可执行文件。由于VS的版本比较多，不同的版本使用CMake会有一些差距，这里就以Virsual Studio 2017为例

1. 首先打开VS，选中 文件->打开->CMake

2. 然后选择QPanda-example文件夹中的示例下的CMakeLists.txt点击，就会打开一个示例

3. 再选择CMakeSetting.json文件，修改-DQPANDA_INSTALL_DIR={QPanda2安装目录}

4. 修改后，ctrl+s，选择CMAKE->全部生成

5. 点击图中的下拉小箭头，选择可执行程序

上面介绍了使用cmake打开我们构建好的工程，有兴趣的也可以深入的学习使用cmake构建项目。

vs下的CMakelists配置:

cmake_minimum_required(VERSION 3.1)
project(testQPanda)
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${QPANDA_INSTALL_DIR}/lib/cmake")

set(CMAKE_CXX_STANDARD 14)
if (MSVC)
    list(APPEND EXTRA_LDFLAGS
        -D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING
        -D_CRT_SECURE_NO_WARNINGS
        /bigobj)

    if (NOT USE_MSVC_RUNTIME_LIBRARY_DLL)
        foreach (flag
            CMAKE_C_FLAGS
            CMAKE_C_FLAGS_DEBUG
            CMAKE_C_FLAGS_RELEASE
            CMAKE_C_FLAGS_MINSIZEREL
            CMAKE_C_FLAGS_RELWITHDEBINFO
            CMAKE_CXX_FLAGS
            CMAKE_CXX_FLAGS_DEBUG
            CMAKE_CXX_FLAGS_RELEASE
            CMAKE_CXX_FLAGS_MINSIZEREL
            CMAKE_CXX_FLAGS_RELWITHDEBINFO)

            if (${flag} MATCHES "/MDd")
                string(REGEX REPLACE "/MDd" "/MT" ${flag} "${${flag}}")
            endif()

            if (${flag} MATCHES "/MD")
                string(REGEX REPLACE "/MD" "/MT" ${flag} "${${flag}}")
            endif()

            if (${flag} MATCHES "/W3")
                string(REGEX REPLACE "/W3" "/W0" ${flag} "${${flag}}")
            endif()
        endforeach()
    endif()
endif()

set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

find_package(QPANDA REQUIRED)
include_directories(${QPANDA_INCLUDE_DIR})

add_executable(${PROJECT_NAME} GateTypeValidator.cpp)
target_link_libraries(${PROJECT_NAME} ${QPANDA_LIBRARIES})

Linux

gcc

在Linux环境下，用户也可以使用g++编译test.cpp，编译命令如下所示：

g++ test.cpp -std=c++14 -fopenmp -I{QPanda安装路径}/include/qpanda2/ -I{QPanda安装路径}/include/qpanda2/ThirdParty/ -L{QPanda安装路径}/lib/ -lComponents -lQAlg  -lQPanda2 -lantlr4 -o test

如果宿主机上安装了libcurl，则编译命令如下所示：

g++ test.cpp -std=c++14 -fopenmp -I{QPanda安装路径}/include/qpanda2/ -I{QPanda安装路径}/include/qpanda2/ThirdParty/ -L{QPanda安装路径}/lib/ -lComponents -lQAlg  -lQPanda2 -lantlr4 -lcurl -o test

如果安装的是可以含有CUDA的库，则编译命令如下：

g++ test.cpp -std=c++14 -fopenmp  -I{QPanda安装路径}/include/qpanda2/ -I{QPanda安装路径}/include/qpanda2/ThirdParty/ -L{QPanda安装路径}/lib/ -lComponents -lQAlg  -lQPanda2 -lantlr4  -lGPUQGates -L{cuda安装目录}/lib/  -lcudart  -o test

Note

如遇以下错误：

可以使用如下方法解决（样例CUDA版本为11.2）：

sudo ldconfig /usr/local/cuda-11.2/lib64

CMake

在Linux环境下，用户也可以使用CMake编译test.cpp，编译命令如下所示(以QPanda-example文件夹中的GateTypeValidator示例)：

cd GateTypeValidator
mkdir -p build
cd build
cmake -DQPANDA_INSTALL_DIR=/usr/local/ ..   #本文档样例QPanda的路径是/usr/local/
make

运行编译后文件：

Linux下的CMakelists配置:

#指定 cmake 的最小版本
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)
#引入外部依赖包
find_package(QPANDA REQUIRED)
include_directories(${QPANDA_INCLUDE_DIR})
# 生成可执行文件
add_executable(${PROJECT_NAME} test.cpp)
target_link_libraries(${PROJECT_NAME} ${QPANDA_LIBRARIES})

MacOS

Clang

在MacOS环境下，用户可以使用Clang编译test.cpp，编译命令如下所示：

clang++ test.cpp -std=c++14 -fopenmp -I{QPanda安装路径}/include/qpanda2/ -I{QPanda安装路径}/include/qpanda2/ThirdParty/ -L{QPanda安装路径}/lib/ -lQPanda2 -lComponents -lantlr4 -o test

含有CUDA的编译指令

clang++ test.cpp -std=c++14 -fopenmp -I{QPanda安装路径}/include/qpanda2/ -I{QPanda安装路径}/include/qpanda2/ThirdParty/ -L{QPanda安装路径}/lib/ -lQPanda2 -lComponents -lantlr4 -lGPUQGates -L{CUDA安装路径}/lib/  -lcudart -o test

CMake

在MacOS环境下，用户也可以使用CMake编译test.cpp，编译命令如下所示：

cd test
mkdir -p build
cd build
cmake -DQPANDA_INSTALL_DIR=/usr/local/ ..
make

本文档样例QPanda的路径是/usr/local/

运行编译后文件：

MacOS下的CMakelists配置:

#指定 cmake 的最小版本
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)
#引入外部依赖包
find_package(QPANDA REQUIRED)
include_directories(${QPANDA_INCLUDE_DIR})
# 生成可执行文件
add_executable(${PROJECT_NAME} test.cpp)
target_link_libraries(${PROJECT_NAME} ${QPANDA_LIBRARIES})

Note

其他样例请参照我们的示例项目 QPanda-Example

量子逻辑门

---

经典计算中，最基本的单元是比特，而最基本的控制模式是逻辑门。我们可以通过逻辑门的组合来达到我们控制电路的目的。类似地，处理量子比特的方式就是量子逻辑门。 使用量子逻辑门，我们有意识的使量子态发生演化。所以量子逻辑门是构成量子算法的基础。

量子逻辑门由酉矩阵表示。最常见的量子门在一个或两个量子位的空间上工作，就像常见的经典逻辑门在一个或两个位上操作一样。

常见量子逻辑门矩阵形式

单比特量子逻辑门：

	I	\(\begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix}\quad\)
	Hadamard	\(\begin{bmatrix} 1/\sqrt {2} & 1/\sqrt {2} \\ 1/\sqrt {2} & -1/\sqrt {2} \end{bmatrix}\quad\)
	T	\(\begin{bmatrix} 1 & 0 \\ 0 & \exp(i\pi / 4) \end{bmatrix}\quad\)
	S	\(\begin{bmatrix} 1 & 0 \\ 0 & 1i \end{bmatrix}\quad\)
	Pauli-X	\(\begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix}\quad\)
	Pauli-Y	\(\begin{bmatrix} 0 & -1i \\ 1i & 0 \end{bmatrix}\quad\)
	Pauli-Z	\(\begin{bmatrix} 1 & 0 \\ 0 & -1 \end{bmatrix}\quad\)
	X1	\(\begin{bmatrix} 1/\sqrt {2} & -1i/\sqrt {2} \\ -1i/\sqrt {2} & 1/\sqrt {2} \end{bmatrix}\quad\)
	Y1	\(\begin{bmatrix} 1/\sqrt {2} & -1/\sqrt {2} \\ 1/\sqrt {2} & 1/\sqrt {2} \end{bmatrix}\quad\)
	Z1	\(\begin{bmatrix} \exp(-i\pi/4) & 0 \\ 0 & \exp(i\pi/4) \end{bmatrix}\quad\)
	RX	\(\begin{bmatrix} \cos(\theta/2) & -1i×\sin(\theta/2) \\ -1i×\sin(\theta/2) & \cos(\theta/2) \end{bmatrix}\quad\)
	RY	\(\begin{bmatrix} \cos(\theta/2) & -\sin(\theta/2) \\ \sin(\theta/2) & \cos(\theta/2) \end{bmatrix}\quad\)
	RZ	\(\begin{bmatrix} \exp(-i\theta/2) & 0 \\ 0 & \exp(i\theta/2) \end{bmatrix}\quad\)
	U1	\(\begin{bmatrix} 1 & 0 \\ 0 & \exp(i\theta) \end{bmatrix}\quad\)
	U2	\(\begin{bmatrix} 1/\sqrt {2} & -\exp(i\lambda)/\sqrt {2} \\ \exp(i\phi)/\sqrt {2} & \exp(i\lambda+i\phi)/\sqrt {2} \end{bmatrix}\quad\)
	U3	\(\begin{bmatrix} \cos(\theta/2) & -\exp(i\lambda)×\sin(\theta/2) \\ \exp(i\phi)×\sin(\theta/2) & \exp(i\lambda+i\phi)×\cos(\theta/2) \end{bmatrix}\quad\)
	U4	\(\begin{bmatrix} u0 & u1 \\ u2 & u3 \end{bmatrix}\quad\)

多比特量子逻辑门：

	CNOT	\(\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{bmatrix}\quad\)
	CR	\(\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & \exp(i\theta) \end{bmatrix}\quad\)
	iSWAP	\(\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & \cos(\theta) & -i×\sin(\theta) & 0 \\ 0 & -i×\sin(\theta) & \cos(\theta) & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}\quad\)
	SWAP	\(\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}\quad\)
	CZ	\(\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & -1 \end{bmatrix}\quad\)
	CU	\(\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & u0 & u1 \\ 0 & 0 & u2 & u3 \end{bmatrix}\quad\)
	Toffoli	\(\begin{bmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\ \end{bmatrix}\quad\)

QPanda-2把所有的量子逻辑门封装为API向用户提供使用，并可获得QGate类型的返回值。比如，您想要使用Hadamard门，就可以通过如下方式获得：

QGate h = H(qubit);

可以看到，H函数只接收一个qubit，qubit如何申请会在 QuantumMachine 部分介绍。

再比如，您想要使用RX门，可以通过如下方式获得：

QGate rx = RX(qubit, PI);

如上所示，RX门接收两个参数，第一个是目标量子比特，第二个偏转角度。您也可以通过相同的方式使用RY，RZ门。

两比特量子逻辑门的使用和单比特量子逻辑门的用法相似，只不过是输入的参数不同，举个使用CNOT的例子：

QGate cnot = CNOT(control_qubit, target_qubit);

CNOT门接收两个参数，第一个是控制比特，第二个是目标比特。

接口介绍

在本章的开头介绍过，所有的量子逻辑门都是酉矩阵，那么您也可以对量子逻辑门做转置共轭操作。QGate类型有两个成员函数可以做转置共轭操作： dagger、setDagger。

setDagger的作用是根据输入参数更新当前量子逻辑门的dagger标记，在计算时计算后端会根据dagger判断当前量子逻辑门是否需要执行转置共轭操作。举个列子：

auto gate = H(qubit);
gate.setDagger(true);

Note

setDagger有一个布尔类型参数，用来设置当前逻辑门是否需要转置共轭操作。

dagger的作用是复制一份当前的量子逻辑门，并更新复制的量子逻辑门的dagger标记。举个例子：

QGate rx_dagger = RX(qubit,PI).dagger();

除了转置共轭操作，您也可以为量子逻辑门添加控制比特，添加控制比特后，当前量子逻辑门是否执行需要根据控制比特的量子态决定。如果控制比特的量子态为|1>态时，当前量子逻辑门可被执行， 如果控制比特的量子态为|0>时，当前量子逻辑门不会被执行。QGate类型有两个成员函数帮助您添加控制比特：control、setControl。

setControl的作用是给当前的量子逻辑门添加控制比特，例如：

auto gate = RX(qubit,PI)
gate.setControl(qvec);

control的作用是复制当前的量子逻辑门，并给复制的量子逻辑门添加控制比特，例如：

QGate rx_control = RX(qubit,PI).control(qvec);

Note

setControl、control都需要接收一个参数，参数类型为QVec，QVec是qubit的vector。

实例

以下实例主要是向您展现QGate类型接口的使用方式，我们先使用init接口初始化一个量子虚拟机，向量子虚拟机申请3个量子比特，并把q[0],q[1]存放在一个量子比特容器中。 接着，调用createEmptyQProg构建一个量子程序prog，然后我们可以通过 << 操作符把量子逻辑门插入到prog中。最后调用probRunTupleList概率测量运行接口，就可以得到计算结果了。

#include "QPanda.h"
using namespace QPanda;

int main(void)
{
    init(QMachineType::CPU);
    auto q = qAllocMany(3);
    QVec qubits = {q[0],q[1]};

    // 构建量子程序
    auto prog = createEmptyQProg();
    prog << H(q[0])
         << H(q[1])
         << H(q[0]).dagger()
         << X(q[2]).control(qubits);

    // 概率测量，并返回目标量子比特的概率测量结果，下标为十进制
    auto result = probRunTupleList(prog, q);

    // 打印测量结果
    for(auto & aiter : result)
    {
        std::cout << aiter.first << " : " << aiter.second << std::endl;
    }

    finalize();
    return 0;
}

计算结果如下：

000:0.5
010:0.5

量子线路

---

量子线路，也称量子逻辑电路是最常用的通用量子计算模型，表示在抽象概念下，对于量子比特进行操作的线路，是各种逻辑门组成的集合。最后常需要量子测量将结果读取出来。

不同于传统电路是用金属线所连接以传递电压讯号或电流讯号，在量子线路中，线路是由时间所连接，亦即量子比特的状态随着时间自然演化，过程中是按照哈密顿运算符的指示，一直到遇上逻辑门而被操作。

由于组成量子线路的每一个量子逻辑门都是一个 酉矩阵 ，所以整个量子线路整体也是一个大的酉矩阵。

量子算法线路图

---

在目前的量子计算理论研究中，各种量子算法常用量子线路表示，比如下方列出的量子算法中的 HHL算法 量子线路图。

接口介绍

---

在QPanda2中，QCircuit类是一个仅装载量子逻辑门的容器类型，它也是QNode中的一种，初始化一个QCircuit对象有以下两种

C++风格

QCircuit cir = QCircuit();

C语言风格

QCircuit cir = CreateEmptyCircuit();

或

QCircuit cir = createEmptyCircuit();

你可以通过如下方式向QCircuit尾部填充节点

QCircuit << QGate;

QGate是量子逻辑门类型。

同时，你也可以对目标线路施加装置共轭和受控操作，QCircuit类型有两个成员函数可以做转置共轭操作： dagger、setDagger。

setDagger的作用是根据输入参数更新当前量子线路的dagger标记，在计算时计算后端会根据dagger判断当前量子逻辑门是否需要执行转置共轭操作。举个例子：

QCircuit cir;
cir.setDagger(true);

该函数需要一个布尔类型参数，用来设置当前逻辑门是否需要转置共轭操作。

dagger的作用是复制一份当前的量子线路，并更新复制的量子线路的dagger标记。举个例子：

QCircuit cir;
QCircuit cir_dagger = cir.dagger();

除了转置共轭操作，您也可以为量子线路添加控制比特.QCircuit类型有两个成员函数用于添加控制比特：control、setControl。

setControl的作用是给当前的量子线路添加控制比特，例如：

QCircuit cir;
cir.setControl(qvec);

control的作用是复制当前的量子线路，并给复制的量子线路添加控制比特，例如：

QCircuit cir;
QCircuit cir_control = cir.control(qvec);

上述都需要接收一个参数，参数类型为QVec，QVec是qubit的vector容器类型。

Note

• 向QCircuit中插入QPorg，QIf，Measure中不会报错，但是运行过程中可能会产生预料之外的错误

• 一个构建好的QCircuit不能直接参与量子计算与模拟，需要进一步构建成QProg类型

实例

---

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    init();
    auto qvec = qAllocMany(4);
    auto cbits = cAllocMany(4);
    auto circuit = createEmptyCircuit();
    auto prog = createEmptyQProg();

    // 构建量子线路
    circuit << H(qvec[0]) << CNOT(qvec[0], qvec[1])
            << CNOT(qvec[1], qvec[2]) << CNOT(qvec[2], qvec[3]);

    // 设置量子线路共轭转置
    circuit.setDagger(true);

    // 构建量子程序，将量子线路插入到量子程序中
    prog << H(qvec[3]) << circuit << Measure(qvec[0], cbits[0]);

    // 量子程序运行1000次，并返回测量结果
    auto result = runWithConfiguration(prog, cbits, 1000);

    // 打印量子态在量子程序多次运行结果中出现的次数
    for (auto &val : result)
    {
        std::cout << val.first << ", " << val.second << std::endl;
    }

    finalize();
    return 0;
}

运行结果：

0000, 510
1000, 490

Warning

CreateEmptyCircuit 接口在后续的版本中会被舍弃。

构建模块化的量子线路

在比特数量比较多，量子算法比较复杂的情况下，可能我们需要把多个比较小的量子线路组成成一整个大的量子程序。

QPanda-2可以以一种比较方便的模式去构建这种模块。

用于生成量子线路（量子程序）的函数

QPanda中最常见的做法是用C++函数来定义一个量子线路模块。它通常具有一个QCircuit或者QProg类型的返回值。例如

QCircuit foo(Qubit* qubit1, Qubit* qubit2)
{
    QCircuit cir;
    cir << H(qubit2) << CNOT(qubit1, qubit2) << H(qubit2);
    return cir;
}

这样的一个函数代表了一个模块（如图），当以不同的qubit1和qubit2作为输入的时候，它相当于把这个模块放置在了量子线路的不同位置

Qubit分配（qAlloc）与映射

QPanda-2中量子比特是用一个Qubit*的指针对象进行表示的。Qubit本身不包含任何和量子态相关的数据，它只是一个用于映射物理量子比特的对象。

qAlloc这个函数可以从量子芯片未用到的量子比特池中申请一个量子比特。qAllocMany则可以申请到一批。

示例：

Qubit* q=qAlloc();
QVec qs=qAllocMany(3);

如图：

在任何时候Qubit * 类型的对象（或者Qvec容器中包含的每一个Qubit*）对象，都是映射到量子芯片上一个位置。 在一开始申请的时候，用户无需指定这种映射关系（通过allocateQubitThroughPhyAddress可以进行手动指定），程序后面可以通过自动的优化器来根据量子程序进行重新映射，以便得到最简的量子程序。

使用编写好的模块

前面写好的foo，就可以被用于不同的量子比特上，以构建一个更大的量子程序。例如我们可以把这一段线路作用在q和qs上：

QProg prog;
prog << foo(q, qs[0]) << foo(qs[1],qs[2]) << foo(qs[2], q);

这样，这个量子程序对应了下面这个量子线路：

利用QVec（vector<Qubit*>)构建模块的方式

QVec继承了vector<Qubit*>类，因此它可以覆盖所有vector所包含的功能（operator[]，size()，push_back，iterator……），当然也可以利用C++11的新式for循环。

下面这个程序利用了一组量子比特（数量不定）去构建一个量子线路，对这组量子比特中每一个，都作用一个Hadamard门。

QCircuit foo2(QVec qs)
{
    QCircuit cir;
    for (auto qubit: qs){
        cir << H(q);
    }
    return cir;
}

如果qs中只有一个量子比特，那这个线路就是：

如果qs中有N个量子比特，那这个线路自然就是：

请问：下面这个量子程序代表了一个什么样的模块呢？

QCircuit foo2(QVec qs)
{
    QCircuit cir;
    cir << H(q[0]);
    for (int i=1;i<qs.size();++i)
    {
        cir << CNOT(q[i-1], q[i]);
    }
    return cir;
}

答案是如图所示：

QWhile

---

量子程序循环控制操作，输入参数为条件判断表达式，功能是执行while循环操作。

接口介绍

---

在QPanda2中，QWhileProg类用于表示执行量子程序while循环操作，初始化一个QWhileProg对象有以下两种方式：

C++风格

QWhileProg qwile = QWhileProg(ClassicalCondition, QProg);

C语言风格

QWhileProg qwile = CreateWhileProg(ClassicalCondition, QProg);

QWhileProg qwile = createWhileProg(ClassicalCondition, QProg);

上述函数需要提供两个参数，即ClassicalCondition(量子表达式)与QProg(量子程序)

Note

由于QNode*、 shared_ptr<QNode>、QCircuit、QIfProg、QWhileProg、QGate、QMeasure、ClassicalCondition可以隐式转换为QProg， 所以在构建QWhile时第二个参数也可以传入上述中的任意一种节点。

同时，通过该类内置的函数可以轻松获取QWhile操作正确分支

QWhileProg qwhile = createWhileProg(ClassicalCondition, QProg);
QNode* true_branch = qwhile.getTrueBranch();

也可以获取量子表达式

QWhileProg qwhile = createWhileProg(ClassicalCondition, QProg);
ClassicalCondition cc = qwhile.getCExpr();

或

QWhileProg qwhile = createWhileProg(ClassicalCondition, QProg);
ClassicalCondition cc = qwhile.getClassicalCondition();

具体的操作流程可以参考下方示例

实例

---

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    init();
    QProg prog;
    auto qvec = qAllocMany(3);
    auto cvec = cAllocMany(3);
    cvec[0].set_val(0);

    // 构建QWhile的循环分支
    QProg prog_in;
    prog_in << cvec[0] << H(qvec[cvec[0]]) << (cvec[0] = cvec[0]+1);

    // 构建QWhile
    auto qwhile = createWhileProg(cvec[0]<3, prog_in);

    // QWhile插入到量子程序中
    prog << qwhile;

    // 概率测量，并返回目标量子比特的概率测量结果，其对应的下标为十进制
    auto result = probRunTupleList(prog, qvec);

    // 打印测量结果
    for (auto & val : result)
    {
        std::cout << val.first << ", " << val.second << std::endl;
    }

    finalize();
    return 0;
}

运行结果：

0, 0.125
1, 0.125
2, 0.125
3, 0.125
4, 0.125
5, 0.125
6, 0.125
7, 0.125

Warning

CreateQWhile、 getCExpr 等在后续的版本中会被舍弃。

QIf

---

QIf表示量子程序条件判断操作，输入参数为条件判断表达式，功能是执行条件判断。

接口介绍

---

在QPanda2中，QIfProg类用于表示执行量子程序条件判断操作，初始化一个QIfProg对象有以下两种方式：

C++风格

QIfProg qif = QIfProg(ClassicalCondition, QProg);
QIfProg qif = QIfProg(ClassicalCondition, QProg, QProg);

C语言风格

QIfProg qif = CreateIfProg(ClassicalCondition, QProg);
QIfProg qif = CreateIfProg(ClassicalCondition, QProg, QProg);

QIfProg qif = createIfProg(ClassicalCondition, QProg);
QIfProg qif = createIfProg(ClassicalCondition, QProg, QProg);

上述函数需要提供两种类型参数，即ClassicalCondition与QProg， 当传入1个QProg参数时，QProg表示正确分支，当传入2个QProg参数时，第一个表示正确分支，第二个表示错误分支

Note

由于QNode*、 shared_ptr<QNode>、QCircuit、QIfProg、QWhileProg、QGate、QMeasure、ClassicalCondition可以隐式转换为QProg， 所以在构建QIf时第二个参数或第三个参数也可以传入上述中的任意一种节点。

同时，通过该类内置的函数可以轻松获取QIf操作正确分支与错误分支

QIfProg qif = createIfProg(ClassicalCondition, QProg, QProg);
QNode* true_branch  = qif.getTrueBranch();
QNode* false_branch = qif.getFalseBranch();

也可以获取量子表达式

QIfProg qif = createIfProg(ClassicalCondition, QProg, QProg);
ClassicalCondition cc = qif.getCExpr();

或

QIfProg qif = createIfProg(ClassicalCondition, QProg, QProg);
ClassicalCondition cc = qif.getClassicalCondition();

实例

---

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    init();
    QProg prog;

    auto qvec = qAllocMany(3);
    auto cvec = cAllocMany(3);
    cvec[1].set_val(0);
    cvec[0].set_val(0);

    QProg branch_true, branch_false;

    // 构建QIf正确分支以及错误分支
    branch_true << H(qvec[cvec[0]]) << (cvec[0]=cvec[0]+1);
    branch_false << H(qvec[0]) << CNOT(qvec[0],qvec[1]) << CNOT(qvec[1],qvec[2]);

    // 构建QIf
    auto qif = createIfProg(cvec[1]>5, branch_true, branch_false);

    // QIf插入到量子程序中
    prog << qif;

    // 概率测量，并返回目标量子比特的概率测量结果，下标为十进制
    auto result = probRunTupleList(prog, qvec);

    // 打印概率测量结果
    for (auto & val : result)
    {
        std::cout << val.first << ", " << val.second << std::endl;
    }

    finalize();
    return 0;
}

运行结果：

0, 0.5
7, 0.5
1, 0
2, 0
3, 0
4, 0
5, 0
6, 0

Warning

CreateIfProg、 getCExpr 等在后续的版本中会被舍弃。

量子程序

---

量子程序设计用于量子程序的编写与构造，一般地， 可以理解为一个操作序列。由于量子算法中也会包含经典计算，因而业界设想，最近将来出现的量子计算机是混合结构的，它包含两大部分一部分是经典计算机，负责执行经典计算与控制；另一部分是量子设备，负责执行量子计算。QPanda-2将量子程序的编程过程视作经典程序运行的一部分，在整个外围的宿主机程序中，一定包含创建量子程序的部分。

接口介绍

---

在QPanda2中，QProg是量子编程的一个容器类，是一个量子程序的最高单位,初始化一个空的QProg对象有以下两种

C++风格

QProg prog = QProg();

C语言风格

QProg prog = CreateEmptyQProg();

或

QProg prog = createEmptyQProg();

QProg的构造函数还有以下几种：

通过量子线路构造量子程序：

auto qubit = qAlloc();
QCircuit circuit;
circuit << H(qubit);
QProg prog(circuit);

通过QIf构造量子程序：

auto qubit = qAlloc();
auto cbit = cAlloc();
cbit.set_val(3);
QCircuit circuit;
circuit << H(qubit);
QIfProg qif(cbit > 3, circuit);
QProg prog(qif);

通过QWhile构造量子程序：

auto qubit = qAlloc();
auto cbit = cAlloc();
cbit.set_val(3);
QCircuit circuit;
circuit << H(qubit);
QWhileProg qwhile(cbit > 3, circuit);
QProg prog(qwhile);

通过QGate构造量子程序：

auto qubit = qAlloc();
auto gate = H(qubit);
QProg prog(gate);

通过QMeasure构建量子程序：

auto qubit = qAlloc();
auto cbit = cAlloc();
auto measure = Measure(qubit, cbit);
QProg prog(measure);

通过ClassicalCondition构建量子程序：

auto cbit = cAlloc();
QProg prog(cbit);

实现QProg的这么多构造函数主要是为了实现各种节点类型向QProg的隐式转换，如：

auto qubit = qAlloc();
auto cbit = cAlloc();
cbit.set_val(1);
auto gate = H(qubit);
auto qif = QIfProg(cbit > 1, gate);

构建QIf的第二个参数本来是要传入QProg的， 但由于QGate可以构造QProg， 在使用时传入参数QGate就会隐士转换为QProg，方便使用。

你可以通过如下方式向QProg尾部填充节点

QProg << QNode;

或者

QProg.pushBackNode(QNode *);

QNode的类型有QGate，QPorg，QIf，Measure等等，QProg支持插入所有类型的QNode

通常一个QProg类型内部结构复杂，需要对其进行拆分遍历等过程，QPanda2提供了相关接口

获取QProg内部第一个节点与最后一个节点

QProg prog = QProg();
NodeIter first_node = prog.getFirstNodeIter();
NodeIter last_node  = prog.getLastNodeIter();

在QProg内部插入与删除节点操作

QProg prog = QProg();
NodeIter insert_node_iter = prog.insertQNode(NodeIter&, QNode*);
NodeIter delete_node_iter = prog.deleteQNode(NodeIter&);

Note

• NodeIter是一个关于QNode的代理类，类似于STL容器的迭代器类型，支持自增与自减等操作

• QProg节点插入删除操作会返回指向原位置的NodeIter

实例

---

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    init();
    auto qvec = qAllocMany(4);
    auto cvec = cAllocMany(4);

    QProg prog;

    // 构建量子程序
    prog << H(qvec[0])
        << X(qvec[1])
        << iSWAP(qvec[0], qvec[1])
        << CNOT(qvec[1], qvec[2])
        << H(qvec[3])
        << MeasureAll(qvec ,cvec);

    // 量子程序运行1000次，并返回多次测量的结果
    auto result = runWithConfiguration(prog, cvec, 1000);

    // 打印量子态在量子程序多次运行结果中出现的次数
    for (auto &val : result)
    {
        std::cout << val.first << ", " << val.second << std::endl;
    }

    finalize();
    return 0;
}

运行结果：

1000, 242
1001, 277
1110, 254
1111, 227

Warning

CreateEmptyQProg 接口在后续的版本中会被舍弃。

量子虚拟机

在真正的量子计算机没有成型之前，需要使用量子虚拟机承担量子算法、量子应用的验证的问题，QPanda-2现在支持全振幅量子虚拟机、单振幅量子虚拟机、部分振幅量子虚拟机 以及含噪声量子虚拟机。

全振幅量子虚拟机

全振幅量子虚拟机一次可以模拟计算出量子态的所有振幅，计算方式支持CPU、单线程计算和GPU，可以在初始化时配置，使用方式是完全一样的，只是其计算效率不同。

接口介绍

全振幅量子虚拟机类型：

enum QMachineType {
    CPU,  /**< Cpu quantum machine  */
    GPU, /**< Gpu quantum machine  */
    CPU_SINGLE_THREAD, /**< Cpu quantum machine with single thread */
    NOISE  /**< Cpu quantum machine with  noise */
};

QPanda2中在构造量子虚拟机时有以下几种方式：

init(QMachineType::CPU);  // 使用init,不会返回qvm，会在代码中生成一个全局的qvm
auto qvm = initQuantumMachine(QMachineType::CPU); // 通过接口得到qvm指针
CPUQVM *qvm = new CPUQVM; // 直接new一个需要qvm类

Note

init 和 initQuantumMachine 这两个函数不是线程安全的，不适用于多线程编程，而且其最大的量子比特个数和经典寄存器个数均为默认值25。

设置量子虚拟机的配置(当前配置只有最大量子比特个数和最大经典寄存器个数):

Configuration conf;
conf.maxQubit = 30;
conf.maxCMem = 30;
qvm->setConfigure(conf);

Note

量子虚拟机默认的最大量子比特个数和经典寄存器个数均为25。

设置好配置之后要初始化量子虚拟机：

qvm->init();

Note

调用 init 和 initQuantumMachine 接口， 就不需要初始化了。

下面我们就需要去申请量子比特和经典寄存器。

例如我们申请4个量子比特：

QVec qubits = qvm->qAllocMany(4);

申请一个量子比特时也可以用这个接口：

Qubit* qubit = qvm->qAlloc();

如果我们想在固定的量子比特虚拟地址上申请一个量子比特可以用下面的方法：

Qubit* qubit = qvm->allocateQubitThroughVirAddress(0x01);

申请经典寄存器也有类似于申请量子比特的接口，其使用方法和申请量子比特的方法一样，如申请4个经典寄存器的方法：

std::vector<ClassicalCondition> cbits = qvm->cAllocMany(4);

申请一个经典寄存器时也可以用这个接口：

ClassicalCondition cbit = qvm->cAlloc();

固定的经典寄存器虚拟地址上申请一个量子比特可以用下面的方法：

ClassicalCondition cbit = qvm->cAlloc(0x01);

在一个量子虚拟机中，申请了几次量子比特或经典寄存器，我们想知道一共申请了多少个量子比特或经典寄存器可以用下面的方法：

size_t num_qubit = qvm->getAllocateQubitNum(); // 申请量子比特的个数
size_t num_cbit = qvm->getAllocateCMemNum(); // 申请经典寄存器的个数

我们该如何使用量子虚拟机来执行量子程序呢？ 可以用下面的方法：

QProg prog;
prog << H(qubits[0])
    << CNOT(qubits[0], qubits[1])
    << Measure(qubits[0], cbits[0]); // 构建一个量子程序

map<string, bool> result = qvm->directlyRun(prog); // 执行量子程序

如果想多次运行一个量子程序，并得到每次量子程序的结果，除了循环调用 directlyRun 方法外， 我们还提供了一个接口 runWithConfiguration 。 runWithConfiguration 有两个重载方法，一个是int类型的配置参数，另一个是rapidjson::Document类型的配置参数。其中int类型的配置参数用法如下：

int shots = 1000;
qvm->runWithConfiguration(prog, cbits, shots);

runWithConfiguration 另个重载方法是为了以后的扩展，配置参数类型为rapidjson::Document， rapidjson::Document保存的是一个Json对象，由于现在只支持 量子程序运行次数的配置， 其json数据结构为：

{
    "shots":1000
}

利用rapidjson库去得到rapidjson::Document对象， rapidjson的使用可以参照 Rapidjson首页 。举个例子如下：

int shots = 1000;
rapidjson::Document doc;
doc.Parse("{}");
doc.AddMember("shots",
    shots,
    doc.GetAllocator());
qvm->runWithConfiguration(prog, cbits, doc);

如果想得到量子程序运行之后各个量子态的振幅值，可以调用 getQState 函数获得：

QStat stat = qvm->getQState();

量子虚拟机中测量和概率使用方法与 量子测量 和 概率测量 中介绍的相同，在这里就不多做赘述。

实例1

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    CPUQVM qvm;
    qvm.init();
    auto qubits = qvm.qAllocMany(4);
    auto cbits = qvm.cAllocMany(4);

    // 构建量子程序
    QProg prog;
    prog << H(qubits[0])
        << CNOT(qubits[0], qubits[1])
        << CNOT(qubits[1], qubits[2])
        << CNOT(qubits[2], qubits[3])
        << Measure(qubits[0], cbits[0]);

    // 量子程序运行1000次，并返回测量结果
    auto result = qvm.runWithConfiguration(prog, cbits, 1000);

    // 打印量子态在量子程序多次运行结果中出现的次数
    for (auto &val : result)
    {
        std::cout << val.first << ", " << val.second << std::endl;
    }

    qvm.finalize();
    return 0;
}

运行结果：

0000, 498
1000, 502

Note

这个量子程序的运行结果是不确定的，但其 0000 和 1000 对应的值都应该在500左右。

实例2

#include <QPanda.h>
USING_QPANDA

int main(void)
{
    init();
    auto qubits = qAllocMany(4);
    auto cbits = cAllocMany(4);

    //构建量子程序
    QProg prog;
    prog << H(qubits[0])
        << CNOT(qubits[0], qubits[1])
        << CNOT(qubits[1], qubits[2])
        << CNOT(qubits[2], qubits[3])
        << Measure(qubits[0], cbits[0]);

    auto result = directlyRun(prog);
    for (auto &val : result)
    {
        std::cout << val.first << ", " << val.second << std::endl;
    }

    finalize();
    return 0;
}

运行结果：

c0, 1

含噪声量子虚拟机

在真实的量子计算机中，受制于量子比特自身的物理特性，常常存在不可避免的计算误差。为了能在量子虚拟机中更好的模拟这种误差，在 QuantumMachine 的基础上， QPanda2带来了含噪声量子虚拟机。含噪声量子虚拟机的模拟更贴近真实的量子计算机，我们可以自定义支持的逻辑门类型，自定义逻辑门支持的噪声模型， 通过这些自定义形式，我们使用QPanda2开发量子程序的现实应用程度将更高。

噪声模型介绍

QPanda2的含噪声量子虚拟机为我们提供了丰富的噪声模型，我们可以自定义噪声模型和量子逻辑门的对应关系。噪声模型主要分为两种：单门噪声模型和双门噪声模型。

单门噪声模型

DAMPING_KRAUS_OPERATOR

DAMPING_KRAUS_OPERATOR是量子比特的弛豫过程噪声模型，它的kraus算符和表示方法如下所示：

\(K_1 = \begin{bmatrix} 1 & 0 \\ 0 & \sqrt{1 - p} \end{bmatrix}, K_2 = \begin{bmatrix} 0 & \sqrt{p} \\ 0 & 0 \end{bmatrix}\)

需要一个噪声参数。

DEPHASING_KRAUS_OPERATOR

DEPHASING_KRAUS_OPERATOR是量子比特的退相位过程噪声模型，它的kraus算符和表示方法如下所示：

\(K_1 = \begin{bmatrix} \sqrt{1 - p} & 0 \\ 0 & \sqrt{1 - p} \end{bmatrix}, K_2 = \begin{bmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p} \end{bmatrix}\)

需要一个噪声参数。

DECOHERENCE_KRAUS_OPERATOR

DECOHERENCE_KRAUS_OPERATOR是退相干噪声模型，为上述两种噪声模型的综合，他们的关系如下所示：

\(P_{damping} = 1 - e^{-\frac{t_{gate}}{T_1}}, P_{dephasing} = 0.5 \times (1 - e^{-(\frac{t_{gate}}{T_2} - \frac{t_{gate}}{2T_1})})\)

\(K_1 = K_{1_{damping}}K_{1_{dephasing}}, K_2 = K_{1_{damping}}K_{2_{dephasing}},\)

\(K_3 = K_{2_{damping}}K_{1_{dephasing}}, K_4 = K_{2_{damping}}K_{2_{dephasing}}\)

需要三个噪声参数。

DEPOLARIZING_KRAUS_OPERATOR

DEPOLARIZING_KRAUS_OPERATOR去极化噪声模型，即单量子比特有一定的概率被完全混合态I/2代替, 它的kraus算符和表示方法如下所示：

\(K_1 = \sqrt{1 - 3p/4} × I, K_2 = \sqrt{p}/2 × X\)

\(K_3 = \sqrt{p}/2 × Y, K_4 = \sqrt{p}/2 × Z\)

其中I、X、Y、Z分别代表其量子逻辑门对应的矩阵

需要一个参数

BITFLIP_KRAUS_OPERATOR

BITFLIP_KRAUS_OPERATOR是比特反转噪声模型，它的kraus算符和表示方法如下所示：

\(K_1 = \begin{bmatrix} \sqrt{1 - p} & 0 \\ 0 & \sqrt{1 - p} \end{bmatrix}, K_2 = \begin{bmatrix} 0 & \sqrt{p} \\ \sqrt{p} & 0 \end{bmatrix}\)

需要一个噪声参数。

BIT_PHASE_FLIP_OPRATOR

BIT_PHASE_FLIP_OPRATOR是比特-相位反转噪声模型，它的kraus算符和表示方法如下所示：

\(K_1 = \begin{bmatrix} \sqrt{1 - p} & 0 \\ 0 & \sqrt{1 - p} \end{bmatrix}, K_2 = \begin{bmatrix} 0 & -i \times \sqrt{p} \\ i \times \sqrt{p} & 0 \end{bmatrix}\)

需要一个噪声参数。

PHASE_DAMPING_OPRATOR

PHASE_DAMPING_OPRATOR是相位阻尼噪声模型，它的kraus算符和表示方法如下所示：

\(K_1 = \begin{bmatrix} 1 & 0 \\ 0 & \sqrt{1 - p} \end{bmatrix}, K_2 = \begin{bmatrix} 0 & 0 \\ 0 & \sqrt{p} \end{bmatrix}\)

需要一个噪声参数。

双门噪声模型

双门噪声模型同样也分为上述几种：DAMPING_KRAUS_OPERATOR、DEPHASING_KRAUS_OPERATOR、DECOHERENCE_KRAUS_OPERATOR、DEPOLARIZING_KRAUS_OPERATOR、BITFLIP_KRAUS_OPERATOR、BIT_PHASE_FLIP_OPRATOR、PHASE_DAMPING_OPRATOR。 它们的输入参数与单门噪声模型一致，双门噪声模型的kraus算符和表示与单门噪声模型存在着对应关系：假设单门噪声模型为： \(\{ K1, K2 \}\) ，那么对应的双门噪声模型为 \(\{K1\otimes K1, K1\otimes K2, K2\otimes K1, K2\otimes K2\}\)。

接口介绍

含噪声量子虚拟机的接口和其他量子虚拟机的接口大部分是相同的，但含噪声量子虚拟机不能使用PMEASURE系列的概率测量接口。 使用含噪声虚拟机时，只需要在初始化前设置一些量子逻辑门的噪声模型和对应的参数即可。

目前QPanda2中含噪声量子逻辑门支持的噪声模型有：

enum NOISE_MODEL
{
    DAMPING_KRAUS_OPERATOR,
    DEPHASING_KRAUS_OPERATOR,
    DECOHERENCE_KRAUS_OPERATOR_P1_P2,
    BITFLIP_KRAUS_OPERATOR,
    DEPOLARIZING_KRAUS_OPERATOR,
    BIT_PHASE_FLIP_OPRATOR,
    PHASE_DAMPING_OPRATOR,
    DECOHERENCE_KRAUS_OPERATOR,
};

设置一个参数的噪声模型：

void set_noise_model(const NOISE_MODEL &model, const GateType &type, double prob)
void set_noise_model(const NOISE_MODEL &model, const GateType &type, double prob, const QVec &qubits)
void set_noise_model(const NOISE_MODEL &model, const GateType &type, double prob, const std::vector<QVec> &qubits)

第一个参数为噪声模型类型，第二个参数为量子逻辑门类型，第三个参数为噪声模型所需的参数, 第四个参数是对单个比特设置噪声参数（包含单门和双门），若没有第四个参数则对所有的比特设置相应的噪声模型。

例如：

NoiseQVM qvm;
qvm.init();
auto q = qvm.qAllocMany(4);
auto c = qvm.cAllocMany(4);

// X门所有比特设置比特反转噪声模型
qvm.set_noise_model(NOISE_MODEL::BITFLIP_KRAUS_OPERATOR, GateType::PAULI_X_GATE, 0.1);

// H门作用在q0和q1上时设置去极化噪声模型
QVec qv = {q[0], q[1]};
qvm.set_noise_model(NOISE_MODEL::DEPHASING_KRAUS_OPERATOR, GateType::HADAMARD_GATE, 0.1, qv);

// CNOT门作用在q0、q1和q1、q2上时设置幅值阻尼噪声模型
std::vector<QVec> qves = {{q[0], q[1]}, {q[1], q[2]}};
qvm.set_noise_model(NOISE_MODEL::DAMPING_KRAUS_OPERATOR, GateType::CNOT_GATE, 0.1, qves);

void set_noise_model(const NOISE_MODEL &model, const GateType &type, double T1, double T2, double t_gate);
void set_noise_model(const NOISE_MODEL &model, const GateType &type, double T1, double T2, double t_gate,
                     const QVec &qubits);
void set_noise_model(const NOISE_MODEL &model, const GateType &type, double T1, double T2, double t_gate,
                     const std::vector<QVec> &qubits);

用法与上面的方法相同，只有噪声参数变为退相干的噪声的三个参数。

void set_measure_error(const NOISE_MODEL &model, double prob, const QVec &qubits = {});
void set_measure_error(const NOISE_MODEL &model, double T1, double T2, double t_gate,
                       const QVec &qubits = {});

用法类似于量子逻辑门的噪声模型，第一个参数为噪声模型类型，后面的参数和量子逻辑门的噪声参数。

void set_reset_error(double p0, double p1, const QVec &qubits = {});

p0 表示重置到 \(\left|0\right\rangle\)的概率，p1表示重置到 \(\left|1\right\rangle\)的概率，未被重置的概率为 1-p0-p1。

void set_readout_error(const std::vector<std::vector<double>> &probs_list, const QVec &qubits = {});

示例：

double f0 = 0.9;
double f1 = 0.85'
noise_qm->set_readout_error({{f0, 1 - f0},{1 - f1, f1}}, {q[0]});

表示在读取q0时0读为0的概率为0.9，读为1的概率为1 - f0， 1读为1的概率为0.85，读为0的概率为1 - f1

含噪声虚拟机还支持设置设置带有角度的量子逻辑门的转转角度误差，其接口使用方式如下：

qvm.set_rotation_error(0.05);

即设置角度旋转误差为0.05。

实例

#include "QPanda.h"

int main(void)
{
    NoiseQVM qvm;
    qvm.init();
    auto q = qvm.qAllocMany(4);
    auto c = qvm.cAllocMany(4);

    qvm.set_noise_model(NOISE_MODEL::BITFLIP_KRAUS_OPERATOR, GateType::PAULI_X_GATE, 0.1);
    QVec qv0 = {q[0], q[1]};
    qvm.set_noise_model(NOISE_MODEL::DEPHASING_KRAUS_OPERATOR, GateType::HADAMARD_GATE, 0.1, qv0);
    std::vector<QVec> qves = {{q[0], q[1]}, {q[1], q[2]}};
    qvm.set_noise_model(NOISE_MODEL::DAMPING_KRAUS_OPERATOR, GateType::CNOT_GATE, 0.1, qves);

    double f0 = 0.9;
    double f1 = 0.85;
    qvm.set_readout_error({{f0, 1-f0}, {1-f1, f1}});
    qvm.set_rotation_error(0.05);

    QProg prog;
    prog << X(q[0]) << H(q[0])
        << CNOT(q[0], q[1])
        << CNOT(q[1], q[2])
        << CNOT(q[2], q[3])
        << MeasureAll(q, c);

    auto result = qvm.runWithConfiguration(prog, c, 1000);
    for (auto &item : result)
    {
        cout << item.first << " : " << item.second << endl;
    }

    return 0;
}

运行结果：

0000 : 341
0001 : 82
0010 : 37
0011 : 41
0100 : 37
0101 : 16
0110 : 15
0111 : 28
1000 : 48
1001 : 23
1010 : 19
1011 : 29
1100 : 16
1101 : 51
1110 : 46
1111 : 171

单振幅量子虚拟机

---

目前我们可以通过量子计算的相关理论，用经典计算机实现模拟量子虚拟机。 量子虚拟机的模拟主要有全振幅与单振幅两种解决方案，其主要区别在于，全振幅一次模拟计算就能算出量子态的所有振幅，单振幅一次模拟计算只能计算出 \(2^{N}\) 个振幅中的一个。

然而全振幅模拟量子计算时间较长，计算量随量子比特数指数增长， 在现有硬件下，无法模拟超过49量子比特。通过单振幅量子虚拟机技术可以模拟超过49比特，同时模拟速度有较大提升，且算法的计算量不随量子比特数指数提升。

使用介绍

---

QPanda2中设计了 SingleAmplitudeQVM 类用于运行单振幅模拟量子计算，同时提供了相关接口，它的使用也很简单。

#include "QPanda.h"

USING_QPANDA

int main(void)
{

    //首先构建一个单振幅量子虚拟机
    SingleAmplitudeQVM qvm;

    //初始化和配置量子虚拟机环境
    qvm.init();
    auto qlist = qvm.qAllocMany(10);
    auto clist = qvm.cAllocMany(10);

    //构建量子算法对应的量子线路
    QProg prog;
    prog << HadamardQCircuit(qlist) << CNOT(qlist[1], qlist[5]) << CZ(qlist[3], qlist[5]);

}

以上是前期的准备工作，最后调用计算接口来获取结果，我们设计多种返回值的接口用于满足不同的计算需求， 主要接口有以下几种：

run ：输入参数为执行的量子程序，申请的量子比特，最大RANK，quickBB优化的最大运行时间

pMeasureBinindex ：输入参数为二进制索引字符串，如 pMeasureBinindex("0000000000") ，输出为该索引下的量子态，同时保证字符串长度与测量的比特数相同

pMeasureDecindex ：输入参数为十进制索引字符串，如 pMeasureDecindex("1")

probRunDict ：输入参数为要执行的量子程序，以及要测量的量子比特。输出为对应量子比特的所有态结果。需要注意的是该接口要求量子比特数为30个以内时使用

具体见如下完整的计算示例所述：

完整示例代码

---

以下示例展示了单振幅量子虚拟机接口的使用方式

#include "QPanda.h"
USING_QPANDA
using namespace std;
int main()
{
    //申请单振幅量子虚拟机
    auto qvm = new SingleAmplitudeQVM();
    qvm->init();
    auto qv = qvm->qAllocMany(10);
    auto cv = qvm->cAllocMany(10);

    // 构建测试线路
    auto prog = QProg();
    for_each(qv.begin(), qv.end(), [&](Qubit* val) { prog << H(val); });
    prog << CZ(qv[1], qv[5])
        << CZ(qv[3], qv[5])
        << CZ(qv[2], qv[4])
        << CZ(qv[3], qv[7])
        << CZ(qv[0], qv[4])
        << RY(qv[7], PI / 2)
        << RX(qv[8], PI / 2)
        << RX(qv[9], PI / 2)
        << CR(qv[0], qv[1], PI)
        << CR(qv[2], qv[3], PI)
        << RY(qv[4], PI / 2)
        << RZ(qv[5], PI / 4)
        << RX(qv[6], PI / 2)
        << RZ(qv[7], PI / 4)
        << CR(qv[8], qv[9], PI)
        << CR(qv[1], qv[2], PI)
        << RY(qv[3], PI / 2)
        << RX(qv[4], PI / 2)
        << RX(qv[5], PI / 2)
        << CR(qv[9], qv[1], PI)
        << RY(qv[1], PI / 2)
        << RY(qv[2], PI / 2)
        << RZ(qv[3], PI / 4)
        << CR(qv[7], qv[8], PI);

    // pMeasureBinindex : 获取对应（二进制）量子态概率
    // run 有三个参数，默认2个，
    // 第一个执行的量子程序;
    // 第二个为申请的量子比特
    // 第三个为最大RANK，这里根据内存设置，默认30；
    // 第四个就是quickBB优化的最大运行时间，默认5s
    qvm->run(prog, qv);
    qvm->run(prog);
    cout << qvm->pMeasureBinindex("0001000000") << endl;

    // pMeasureDecindex : 获取对应（10进制）量子态概率
    qvm->run(prog, qv);
    cout << qvm->pMeasureDecindex("1") << endl;

    // getProbDict 获取对应量子比特所有量子态（如果申请比特数超过30， 该接口不提供使用）
    qvm->run(prog, qv);
    auto res_1 = qvm->getProbDict(qv);

    // probRunDict  上面两个接口run和getProbDict的封装
    auto res = qvm->probRunDict(prog, qv);
    for (auto val : res)
    {
        std::cout << val.first << " : " << val.second << std::endl;
    }

    qvm->finalize();
    delete(qvm);
    return 0;
}

bin_index_result 与 dec_index_result 接口分别计算量子态指定二进制和十进制下标的概率，上述程序的计算结果如下

0.00166709
0.00166709

部分振幅量子虚拟机

---

部分振幅量子虚拟机的基本思想是将大比特的量子程序拆分成若干个小比特量子程序，每个小比特量子线路使用全振幅算法计算，量子程序的拆分规则如下： 若量子线路中出现跨节点的双量子逻辑门，则对量子程序进行拆分。即以量子程序中量子比特数为总量子比特数的一半或接近一半为分界线，例如总量子比特数为10，则4号比特与5号比特之间为分界线。 双量子逻辑门的控制位量子比特与目标位量子比特分别处于界线的两侧，称为跨节点，例如总量子比特数为10，CNOT(1,5)为跨节点，CNOT(1,4)则没有跨节点。

部分振幅量子虚拟机根据算法要求，对于跨节点双量子逻辑门，如CNOT、CZ等，可以将其拆分为P0、P1和基础单量子逻辑门的组合，对于其他双量子逻辑门，如CR、iSWAP、SqiSWAP等， 可以通过量子逻辑门转化算法将其转换成单量子逻辑门和支持拆分的双量子逻辑门的组合，再对双量子逻辑门进行拆分，拆分过程的示例图如下：

使用介绍

---

QPanda2中设计了 PartialAmplitudeQVM 类用于运行部分振幅模拟量子计算，同时提供了相关接口，它的使用很简单。

首先构建一个部分振幅量子虚拟机

auto machine = new PartialAmplitudeQVM();

然后必须使用 PartialAmplitudeQVM::init() 初始化量子虚拟机环境

machine->init();

接着进行量子程序的构建、装载工作

auto prog = QProg();
auto qlist = machine->qAllocMany(10);

for_each(qlist.begin(), qlist.end(), [&](Qubit *val) { prog << H(val); });
prog << CZ(qlist[1], qlist[5]) << CZ(qlist[3], qlist[5]) << CZ(qlist[2], qlist[4]);
...
machine->run(prog);

构建还可以采用另一种方式，即读取OriginIR语法文件形式，例如

machine->run("D:\\OriginIR");

最后调用计算接口，我们设计多种返回值的接口用于满足不同的计算需求，具体见示例所述：

实例

---

以下示例展示了部分振幅量子虚拟机接口的使用方式

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto machine = new PartialAmplitudeQVM();
    machine->init();
    auto qlist = machine->qAllocMany(10);

    // 构建量子程序
    auto prog = QProg();
    for_each(qlist.begin(), qlist.end(), [&](Qubit *val) { prog << H(val); });
    prog << CZ(qlist[1], qlist[5])
         << CZ(qlist[3], qlist[7])
         << CZ(qlist[0], qlist[4])
         << RZ(qlist[7], PI / 4)
         << RX(qlist[5], PI / 4)
         << RX(qlist[4], PI / 4)
         << RY(qlist[3], PI / 4)
         << CZ(qlist[2], qlist[6])
         << RZ(qlist[3], PI / 4)
         << RZ(qlist[8], PI / 4)
         << CZ(qlist[9], qlist[5])
         << RY(qlist[2], PI / 4)
         << RZ(qlist[9], PI / 4)
         << CR(qlist[2], qlist[7], PI / 2);

    // 获取量子态所有分量的振幅
    machine->run(prog);
    auto res = machine->getQState();

    // 打印特定量子态分量的振幅
    cout << res["0000000000"] << endl;
    cout << res["0000000001"] << endl;

    machine->finalize();
}

上述程序使用的接口为getQState()，即获取量子态所有分量的振幅，计算结果如下

(-0.00647209,-0.00647209)
(8.5444e-18,-0.00915291)
...

若使用其他接口：

• PMeasure(std::string) ,输入的参数表示获取测量所有比特构成量子态的概率的结果集的前多少项，比如如下例子，我们获取所有量子态的概率分布结果的前6项，程序运行如下：

  auto res = machine->PMeasure("6");
  for (auto val :res)
  {
      std::cout << val.first << " : " << val.second << std::endl;
  }
  

  结果输出如下，每个结果的序号表示量子态的下标，后面的值表示概率：

  0 : 8.37758e-05
  1 : 8.37758e-05
  2 : 8.37758e-05
  3 : 8.37758e-05
  4 : 0.000488281
  5 : 0.000488281
  

• PMeasure(QVec,std::string) ,输入的第一个参数表示选取哪几个量子比特构成的量子态的概率，第二个参数表示选取结果的前多少项，使用示例如下：

  QVec qv = { qlist[1],qlist[2],qlist[3] ,qlist[4] ,qlist[5] ,qlist[6] ,qlist[7] ,qlist[8],qlist[9] };
  auto res2 = machine->PMeasure(qv, "6");
  
  for (auto val :res)
  {
      std::cout << val.first << " : " << val.second << std::endl;
  }
  

  结果输出如下，每个结果的序号表示量子态的下标，后面的值表示概率：

  0 : 0.000167552
  1 : 0.000167552
  2 : 0.000976562
  3 : 0.000976562
  4 : 0.000976562
  5 : 0.000976562
  

• getProbDict(qvec,std::string) ,输入的第一个参数表示选取哪几个量子比特构成的量子态的概率，第二个参数表示选取结果的前多少项，使用示例如下：

  QVec qvec;
  for_each(qlist.begin(), qlist.end(), [&](Qubit *val) { qvec.emplace_back(val); });
  
  auto res = machine->getProbDict(qvec,6);
  for (auto val :res)
  {
      std::cout << val.first << " : " << val.second << endl;
  }
  

  结果输出如下，每个结果的前半部分表示量子态的二进制形式，后面的值表示概率：

  0000000000 : 8.37758e-05
  0000000001 : 8.37758e-05
  0000000010 : 8.37758e-05
  0000000011 : 8.37758e-05
  0000000100 : 0.000488281
  0000000101 : 0.000488281
  

• pMeasureBinIndex(std::string) ,输入的参数表示指定需要测量的量子态二进制形式，使用示例如下：

  auto res = machine->pMeasureBinIndex("0000000001");
  std::cout << res << std::endl;
  

  结果输出如下，表示目标量子态的概率值：

  8.37758e-05
  

• pMeasureDecIndex(std::string) ,输入的参数表示指定需要测量的量子态十进制下标形式，使用示例

  auto res = machine->pMeasureBinIndex("1");
  std::cout << res << std::endl;
  

  结果输出如下，表示目标量子态的概率值：

  8.37758e-05
  

• pMeasureSubset(QProg &, std::vector<std::string>) ,输入的第一个参数表示待运行的量子线路，第二个参数表示需要测量的量子态二进制下标形式构成的子集，使用示例如下：

  std::vector<std::string> set = { "0000000000","0000000001","0000000100" };
  auto res = machine->PMeasureSubset(prog, set);
  
  for (auto val : res)
  {
      std::cout << val.first << " : " << val.second << endl;
  }
  

  结果输出如下：

  0000000000 : 8.37758e-05
  0000000001 : 8.37758e-05
  0000000100 : 0.000488281
  

  Warning

  1. 部分接口，比如 getQState() 、 PMeasure(std::string) 、 PMeasure(QVec,std::string) 、 pMeasureBinIndex(std::string) 以及 pMeasureDecIndex(std::string) 等会在后续的版本中舍弃。

  2. 部分振幅虚拟机会保留 pMeasureSubset(QProg &, std::vector<std::string>) 接口。

张量网络量子虚拟机

---

对于一个 \(N\) 个量子比特的自旋体系，对应的希尔伯特空间维数为 \(2^{N}\) 。

对于该复杂系统的状态演化，传统的全振幅模拟器将其看做一个有 \(2^{N}\) 个元素的一维向量。

然而从张量网络的角度来看，整个系统量子态的系数对应 \(2^{N}\) 维张量（即N阶张量，即有 \(N\) 个指标，每个指标的维数是2），量子操作算符的系数为 \(2^{2N}\) 维张量（ \(2N\) 阶张量，即有个 \(2N\) 指标，每个指标的维数是2），我们可以用如下图形来表示量子态：

当量子系统的自旋个数增加时，量子态系数的个数随指数增加，称为指数墙问题，这一障碍限制了传统全振幅模拟器的最大模拟自旋数和模拟性能。

但是可通过张量网络处理这一问题，从而绕过指数墙障碍，在张量网络中，我们对量子系统的模拟，包括量子逻辑门操作和测量操作，均可以通过对于张量的缩并与分解来实现。矩阵乘积态是张量网络中最常用的表示形式，在多线性代数中称为张量列或TT（Tensor-Train），示意图如下。

将量子态分解成等式右边的表示形式，对于量子线路中部分量子逻辑门操作，可以将全局问题转化为局部的张量处理问题，从而有效地降低了时间复杂度和空间复杂度。

应用场景

---

在量子电路的模拟方法中，选择合适的模拟后端非常重要，不同量子线路模拟器的适用场所如下：

全振幅量子虚拟机 ：全振幅模拟器可以同时模拟和存储量子态的全部振幅，但受限于机器的内存条件，量子比特达到50位已是极限，适合低比特高深度的量子线路，比如低比特下的谷歌随机量子线路以及需要获取全部模拟结果的场景等。

部分振幅量子虚拟机 ：部分振幅模拟器依赖于其他模拟器提供的低比特量子线路振幅模拟结果，能模拟更高的比特数量，但能模拟的深度降低，通常用于获取量子态振幅的部分子集模拟结果。

单振幅量子虚拟机 ：单振幅模拟器能模拟更高的量子比特线路图，同时模拟的性能较高，不会随着量子比特数目增加呈指数型增长，但随着线路深度增加，模拟性能急剧下降，同时难以模拟多控制门也是其缺点，该模拟器适用于高比特低深度的量子线路模拟，通常用于快速地模拟获得单个量子态振幅结果。

张量网络量子虚拟机 ：张量网络模拟器与单振幅类似，与单振幅对比，可以模拟多控制门，同时在深度较高的线路模拟上存在性能优势。

量子云虚拟机 ：量子云虚拟机可以将任务提交在远程高性能计算集群上运行，突破本地硬件性能限制，同时支持在真实的量子芯片上运行量子算法。

使用介绍

---

QPanda2 中设计了 MPSQVM 类用于使用这一方法的模拟器进行模拟量子电路。和许多其他模拟器的使用方法一样，都具有相同的量子虚拟机接口，比如下述代码:

#include "QPanda.h"

USING_QPANDA

int main(void)
{
    //首先构建一个张量网络模拟器
    MPSQVM qvm;

    //对模拟比特上限进行配置
    Configuration config = { 64,64 };
    qvm.setConfig(config);

    //初始化和配置量子虚拟机环境
    qvm.init();
    auto qlist = qvm.qAllocMany(30);
    auto clist = qvm.cAllocMany(30);

    //构建量子算法对应的量子线路
    QProg prog;
    prog << HadamardQCircuit(qlist) << CNOT(qlist[1], qlist[5]) << CZ(qlist[3], qlist[5]) << MeasureAll(qlist,clist);

    //调用模拟接口，获取模拟结果
    auto result = qvm.runWithConfiguration(prog, clist, 1000);

    //释放量子虚拟机系统资源
    qvm.finalize();

}

完整示例代码

---

以下示例展示了张量网络模拟器计算部分接口的使用方式

#include "QPanda.h"

USING_QPANDA

int main(void)
{
    MPSQVM qvm;

    qvm.init();
    auto qlist = qvm.qAllocMany(10);
    auto clist = qvm.cAllocMany(10);

    QProg prog;
    prog << HadamardQCircuit(qlist)
        << CZ(qlist[1], qlist[5])
        << CZ(qlist[3], qlist[5])
        << CZ(qlist[2], qlist[4])
        << CZ(qlist[3], qlist[7])
        << CZ(qlist[0], qlist[4])
        << RY(qlist[7], PI / 2)
        << RX(qlist[8], PI / 2)
        << RX(qlist[9], PI / 2)
        << CR(qlist[0], qlist[1], PI)
        << CR(qlist[2], qlist[3], PI)
        << RY(qlist[4], PI / 2)
        << RZ(qlist[5], PI / 4)
        << RX(qlist[6], PI / 2)
        << RZ(qlist[7], PI / 4)
        << CR(qlist[8], qlist[9], PI)
        << CR(qlist[1], qlist[2], PI)
        << RY(qlist[3], PI / 2)
        << RX(qlist[4], PI / 2)
        << RX(qlist[5], PI / 2)
        << CR(qlist[9], qlist[1], PI)
        << RY(qlist[1], PI / 2)
        << RY(qlist[2], PI / 2)
        << RZ(qlist[3], PI / 4)
        << CR(qlist[7], qlist[8], PI)
        <<MeasureAll(qlist,clist);

        auto measure_result = qvm.runWithConfiguration(prog, clist, 1000);
        for (auto val : measure_result)
        {
            cout << val.first << " : " << val.second << endl;
        }

        auto pmeasure_result = qvm.probRunDict(prog, qlist, -1);
        for (auto val : pmeasure_result)
        {
            cout << val.first << " : " << val.second << endl;
        }

        qvm.finalize();
        return 0;
}

runWithConfiguration 与 probRunDict 接口分别用于Monte Carlo采样模拟和概率测量，他们分别输出模拟采样的结果和对应振幅的概率，上述程序的计算结果如下

//Monte Carlo 采样模拟结果
0000000111 : 1
0000110110 : 1
0000111000 : 2
0001000001 : 3
0001000100 : 1
0001001101 : 1
0001010000 : 2
0001101100 : 1
0001110110 : 1
...

//概率测量结果
0000000000 : 0.0016671
0000000001 : 0.0016671
0000000010 : 0.000286029
0000000011 : 0.000286029
0000000100 : 0.000286029
0000000101 : 0.000286029
0000000110 : 0.0016671
0000000111 : 0.0016671
0000001000 : 0.0016671
0000001001 : 0.0016671
0000001010 : 0.000286029
0000001011 : 0.000286029
...

Note

1. 概率测量还支持其他输出类型的接口，比如 getProbTupleList(QVec, int) 、 probRunTupleList(QProg &, QVec, int) 、 probRunList(QProg &, QVec, int) 、 getQState() 以及 pMeasure(QVec, int) 等，在此不做过多介绍。

2. 后续张量网络量子虚拟机会支持含噪声的模拟，使量子电路的模拟更贴近真实的量子计算机，支持自定义的逻辑门类型和噪声模型，所有的噪声模型和错误包括但不限于 含噪声量子虚拟机 部分提到的内容。

量子比特池

简介

QPanda之前版本中量子比特和经典寄存器都是通过虚拟机进行申请，管理，控制。 现在提供独立于虚拟机的方法，即量子比特、经典寄存器不通过虚拟机管理，可以由提供的比特池直接申请、释放。 为了更好的使用量子比特和经典寄存器，我们进一步支持以物理地址代表相应比特使用。

接口说明

量子比特池：

OriginQubitPool::get_instance() 获取单例的量子比特池， 通过该池对象申请释放量子比特

get_capacity 获取最大容量

set_capacity 设置容量

get_qubit_by_addr 通过物理地址获取量子比特

经典寄存器池：

OriginCMem::get_instance() 获取单例的经典寄存器池，通过该池对象申请释放经典寄存器

get_capacity 获取最大容量

set_capacity 设置容量

get_cbit_by_addr 通过物理地址获取量子比特

由于申请释放方法均和虚拟机提供的方法相同。 在 QuantumMachine 中有详细介绍。 同时对于量子比特和经典寄存器的使用，现在也可以直接通过对应比特的地址传参。

例如 : H(1) 可以理解在物理地址为1的量子比特上作用H门。 Measure(1, 1) 可以理解在物理地址为1的量子比特施加Meausre测量，并将结果保存在地址为1的经典寄存器上。

实例

#include "QPanda.h"
USING_QPANDA
using namespace std;
int main()
{
    // 量子比特可以和虚拟机 脱离关系，获取对应池的单例
    auto qpool = OriginQubitPool::get_instance();
    auto cmem = OriginCMem::get_instance();

    //获取容器大小
    cout << "set qubit pool capacity  before: "<< qpool->get_capacity() << endl;
    // 设置最大容器
    qpool->set_capacity(20);
    cout << "set qubit pool capacity  after: " << qpool->get_capacity() << endl;

    // 通过比特池申请比特，由于是单例模式，要保证申请的比特数量不超过最大容量
    auto qv = qpool->qAllocMany(6);
    auto cv = cmem->cAllocMany(6);

    // 获取被申请的量子比特
    QVec used_qv;
    auto used_qv_size = qpool->get_allocate_qubits(used_qv);
    cout << "allocate qubits number: " << used_qv_size << endl;

    // 构建虚拟机
    auto qvm = new CPUQVM();
    qvm->init();
    auto prog = QProg();
    // 直接使用物理地址作为量子比特信息入参
    prog << H(0) << H(1)
        << H(2)
        << H(4)
        << X(5)
        << X1(2)
        << CZ(2, 3)
        << RX(3, PI / 4)
        << CR(4, 5, PI / 2)
        << SWAP(3, 5)
        << CU(1, 3, PI / 2, PI / 3, PI / 4, PI / 5)
        << U4(4, 2.1, 2.2, 2.3, 2.4)
        << BARRIER({0, 1,2,3,4,5})
        ;

    // 测量方法也可以使用比特物理地址
    auto res_0 = qvm->probRunDict(prog, { 0,1,2,3,4,5 });
    // auto res_1 = qvm->probRunDict(prog, qv);  //同等上述方法


    // 同样经典比特地址也可以作为经典比特信息入参
    prog << Measure(0, 0)
        << Measure(1, 1)
        << Measure(2, 2)
        << Measure(3, 3)
        << Measure(4, 4)
        << Measure(5, 5)
        ;

    // 使用经典比特地址入参
    vector<int> cbit_addrs = { 0,1,2,3,4,5 };
    auto res_2 = qvm->runWithConfiguration(prog, cbit_addrs, 5000);
    // auto res_3 = qvm->runWithConfiguration(prog, cv, 5000); //同等上述方法
    qvm->finalize();
    delete(qvm);


    // 同时我们还可以再次利用这里申请的qv，避免多次使用虚拟机多次申请比特的问题发生
    auto qvm_noise = new NoiseQVM();
    qvm_noise->init();
    auto res_4 = qvm_noise->runWithConfiguration(prog, cbit_addrs, 5000);
    qvm_noise->finalize();
    delete(qvm_noise);

    return 0;
}

运行结果：

set qubit pool capacity  before: 29
set qubit pool capacity  after: 20
allocate qubits number: 6

量子测量

量子测量是指通过外界对量子系统进行干扰来获取需要的信息，测量门使用的是蒙特卡洛方法的测量。在量子线路中用如下图标表示：

接口介绍

本章主要介绍获得量子测量对象、根据配置运行含有量子测量的量子程序、快速测量。

在量子程序中我们需要对某个量子比特做测量操作，并把测量结果存储到经典寄存器上，可以通过下面的方式获得一个测量对象：

auto measure = Measure(qubit, cbit);

可以看到Measure接两个参数， 第一个是测量比特，第二个是经典寄存器。

如果想测量所有的量子比特并将其存储到对应的经典寄存器上， 可以如下操作：

auto measure_all = MeasureAll(qubits, cbits);

其中qubits的类型是 QVec ， cbits的类型是 vector<ClassicalCondition>。

Note

MeasureAll 的返回值类型是 QProg。

在得到含有量子测量的程序后，我们可以调用 directlyRun 或 runWithConfiguration 来得到量子程序的测量结果。

directlyRun 的功能是运行量子程序并返回运行的结果， 使用方法如下：

QProg prog;
prog << H(qubits[0])
    << CNOT(qubits[0], qubits[1])
    << CNOT(qubits[1], qubits[2])
    << CNOT(qubits[2], qubits[3])
    << Measure(qubits[0], cbits[0]);

auto result = directlyRun(prog);

runWithConfiguration 的功能是统计量子程序多次运行的测量结果， 使用方法如下：

QProg prog;
prog   << H(qubits[0])
        << H(qubits[1])
        << H(qubits[2])
        << H(qubits[3])
        << MeasureAll(qubits, cbits); // 测量所有的量子比特

auto result = runWithConfiguration(prog, cbits, 1000);

其中第一个参数是量子程序，第二个参数是经典寄存器， 第三个参数是运行的次数。

实例

#include <QPanda.h>
USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine();
    auto qubits = qvm->qAllocMany(4);
    auto cbits = qvm->cAllocMany(4);

    // 构建量子程序
    QProg prog;
    prog   << H(qubits[0])
            << H(qubits[1])
            << H(qubits[2])
            << H(qubits[3])
            << MeasureAll(qubits, cbits);

    // 量子程序运行1000次，并返回测量结果
    auto result = runWithConfiguration(prog, cbits, 1000);

    // 打印量子态在量子程序多次运行结果中出现的次数
    for (auto &val: result)
    {
        std::cout << val.first << ", " << val.second << std::endl;
    }

    qvm->finalize();
    delete qvm;

    return 0;
}

运行结果：

0000, 47
0001, 59
0010, 74
0011, 66
0100, 48
0101, 62
0110, 71
0111, 61
1000, 70
1001, 57
1010, 68
1011, 63
1100, 65
1101, 73
1110, 55
1111, 61

概率测量

概率测量是指获得目标量子比特的振幅，目标量子比特可以是一个量子比特也可以是多个量子比特的集合。 在QPanda2中概率测量又称为PMeasure, 在QPanda2中的接口为 pMeasure 。 概率测量和 量子测量 是完全不同的过程，Measure是执行了一次测量， 并返回一个确定的0/1结果，并且改变了量子态， PMeasure是获得我们所关注的量子比特的振幅，并不会改变量子态， pMeasure 的输入参数是 QVec ， 它指定了我们关注的量子比特。 例如，一共有10个Qubit的系统，我们指定了前三个Qubit作为 pMeasure 的目标，就会输出一个长度为8的vector。

接口介绍

QPanda2提供了三种获得PMeasure结果的方式，其中有 probRunList 、 probRunTupleList 、 probRunDict。

• probRunList ： 获得目标量子比特的概率测量结果， 并没有其对应的下标。

• probRunTupleList： 获得目标量子比特的概率测量结果， 其对应的下标为十进制。

• probRunDict ： 获得目标量子比特的概率测量结果， 其对应的下标为二进制。

这三个函数的使用方式是一样的，下面就以 probRunDict 为例介绍，使用方式如下：

auto qubits = qvm->qAllocMany(4);

QProg prog;
prog   << H(qubits[0])
        << CNOT(qubits[0], qubits[1])
        << CNOT(qubits[1], qubits[2])
        << CNOT(qubits[2], qubits[3]);
auto result = probRunDict(prog, qubits, 3);

第一个参数是量子程序， 第二个参数是 QVec 它指定了我们关注的量子比特。 第三个参的值为-1时，获取所有的概率测量结果，大于0时表示获取最大的前几个数。

除了上述的方式外，我们还可以先使用 directlyRun， 再调用 getProbList 、 getProbTupleList 、 getProbDict 得到和上述三种方法一样的结果。

实例

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine();
    auto qubits = qvm->qAllocMany(2);

    QProg prog;
    prog << H(qubits[0])
        << CNOT(qubits[0], qubits[1]);

    // 概率测量，并返回目标量子比特的概率测量结果，下标为二进制
    std::cout << "probRunDict: " << std::endl;
    auto result1 = probRunDict(prog, qubits);
    for (auto &val: result1)
    {
        std::cout << val.first << ", " << val.second << std::endl;
    }

    // 概率测量，并返回目标量子比特的概率测量结果，下标为十进制
    std::cout << "probRunTupleList: " << std::endl;
    auto result2 = probRunTupleList(prog, qubits);
    for (auto &val: result2)
    {
        std::cout << val.first << ", " << val.second << std::endl;
    }

    // 概率测量，并返回目标量子比特的概率测量结果， 无下标
    std::cout << "probRunList: " << std::endl;
    auto result3 = probRunList(prog, qubits);
    for (auto &val: result3)
    {
        std::cout << val<< std::endl;
    }

    qvm->finalize();
    delete qvm;
    return 0;
}

运行结果：

probRunDict:
00, 0.5
01, 0
10, 0
11, 0.5
probRunTupleList:
0, 0.5
3, 0.5
1, 0
2, 0
probRunList:
0.5
0
0
0.5

本源量子云服务

在复杂的量子线路模拟中有必要借助于高性能计算机集群或真实的量子计算机，用云计算的方式替代本地计算，在一定程度上减轻用户的计算成本，获得更好的计算体验。

本源量子量子云平台经由调度服务器向部署在远程的量子计算机或计算集群提交任务，并接收返回的结果，流程如下图所示。

pyqpanda封装了量子云虚拟机，可以向本源量子的计算服务器集群或量子真实芯片发送计算指令，并获取计算结果，在使用下文介绍的各种虚拟机之前，需要确保已开通对应的虚拟机产品。

真实芯片计算服务

---

本源悟源超导芯片

本源悟源 是2020年9月12日本源量子自主研发的超导量子计算机（搭载6比特超导量子处理器夸父 KF C6-130）。得益于本源超导量子计算云平台，量子计算机可以走出实验室，为众多潜在行业提供探索量子计算的基础条件，推进量子计算产业落地与工程化发展，真正为人类社会服务。

超导量子计算云平台作为连接用户和量子计算系统之间的桥梁，在用户向量子系统发起计算任务到量子系统完成计算任务后返回计算结果过程中，发挥着重要的协调中转作用。

本源悟源的 芯片拓扑结构图 如下：

对应的 芯片参数 信息如下图：

通过量子云平台向本源悟源请求计算任务的完整代码流程如下：

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    //通过QCloudMachine创建量子云虚拟机
    QCloudMachine QCM;;

    //通过传入当前用户的token来初始化
    QCM.init("3B1AC640AAC248C6A7EE4E8D8537370D");
    auto qlist = QCM.allocateQubits(6);
    auto clist = QCM.allocateCBits(6);

    //构建量子程序
    auto measure_prog = QProg();
    measure_prog << HadamardQCircuit(qlist)
                    << CZ(qlist[1], qlist[5])
                    << CZ(qlist[0], qlist[4])
                    << RX(qlist[2], PI / 4)
                    << RX(qlist[1], PI / 4)
                    << CZ(qlist[2], qlist[3])
                    << Measure(qlist[0], clist[0])
                    << Measure(qlist[1], clist[1])
                    << Measure(qlist[2], clist[2]);

    //调用真实芯片计算接口，需要量子程序和测量次数两个参数
    auto result = QCM.real_chip_measure(measure_prog, 1000);
    for (auto val : result)
    {
        cout << val.first << " : " << val.second << endl;
    }

    QCM.finalize();
    return 0;
}

上述过程需要注意的是， init 需要用户传入量子云平台用户验证标识token，可以从本源量子云平台个人信息下获取，具体见下方截图。

输出结果如下，左侧是量子态的二进制表示，右边表示测量次数对应的概率：

000 : 0.0979978
001 : 0.0912204
010 : 0.101005
011 : 0.130386
100 : 0.124317
101 : 0.142877
110 : 0.155054
111 : 0.157143

在使用本源悟源真实芯片测量操作时，经常会遇到各种错误，下面给出部分错误信息，可以根据抛出的错误异常信息进行对号入座。

• server connection failed ：该异常表示服务器宕机或与服务器连接失败

• api key error ：该异常表示用户的API-Key参数异常，请去官网确认个人资料的信息

• un-activate products or lack of computing power ：该异常表示用户未开通该产品或算力不足

• build system error ：该异常表示编译系统运行出错

• exceeding maximum timing sequence ：该异常表示量子程序时序过长

• unknown task status ：其他任务状态异常的情况

Note

• 使用对应的计算接口时，需要确认当前用户已经开通了该产品，否则可能会导致提交计算任务失败。

• 在噪声模拟时，退相干的单门噪声和双门参数参数分别有3个，不同于其他噪声

• 本源悟源测量操作支持的测量次数范围在1000至10000之间，且目前仅支持6及以下量子比特的量子线路模拟，未来会加入其他的量子芯片，敬请期待。

• 在使用时遇到任何问题，请给我们提交 用户反馈 ，我们看到后会尽快解决你的问题

本源高性能计算集群云服务

---

本源量子的高性能计算集群提供多种功能强大的虚拟机计算后端，适用于不同情况下的量子线路模拟需求，完整示例程序介绍如下：

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    //通过QCloudMachine创建量子云虚拟机
    QCloudMachine QCM;

    //通过传入当前用户的token来初始化
    QCM.init("3B1AC640AAC248C6A7EE4E8D8537370D");
    auto qlist = QCM.allocateQubits(6);
    auto clist = QCM.allocateCBits(6);

    //构建量子程序
    auto measure_prog = QProg();
    measure_prog << HadamardQCircuit(qlist)
                    << CZ(qlist[1], qlist[5])
                    << CZ(qlist[0], qlist[4])
                    << RX(qlist[2], PI / 4)
                    << RX(qlist[1], PI / 4)
                    << CZ(qlist[2], qlist[3])
                    << Measure(qlist[0], clist[0])
                    << Measure(qlist[1], clist[1])
                    << Measure(qlist[2], clist[2]);

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

    //调用全振幅蒙特卡洛测量操作接口，需要量子程序和测量次数两个参数
    auto result0 = QCM.full_amplitude_measure(measure_prog, 100);
    for (auto val : result0)
    {
        cout << val.first << " : " << val.second << endl;
    }

    QCM.finalize();
    return 0;
}

全振幅模拟云计算

• full_amplitude_measure(全振幅蒙特卡洛测量操作) ：

  auto result0 = QCM.full_amplitude_measure(measure_prog, 100);
  for (auto val : result0)
  {
      cout << val.first <<" : "<< val.second << endl;
  }
  

  输出结果如下，左侧是量子态的二进制表示，右边表示测量次数对应的概率：

  000 : 0.12
  001 : 0.14
  010 : 0.15
  011 : 0.12
  100 : 0.11
  101 : 0.11
  110 : 0.11
  111 : 0.14
  

• full_amplitude_pmeasure(全振幅概率测量操作) ：

  auto result1 = QCM.full_amplitude_pmeasure(pmeasure_prog, { 0, 1, 2 });
  for (auto val : result1)
  {
      cout << val.first << " : " << val.second << endl;
  }
  

  需要传入的第二个参数是测量的比特，输出结果如下，左侧是量子态的二进制表示，右边表示测量对应的概率：

  000 : 0.125
  001 : 0.125
  010 : 0.125
  011 : 0.125
  100 : 0.125
  101 : 0.125
  110 : 0.125
  111 : 0.125
  

部分振幅模拟云计算

• partial_amplitude_pmeasure(部分振幅概率测量操作) ：

  auto result2 = QCM.partial_amplitude_pmeasure(pmeasure_prog, { "0", "1", "2"});
  for (auto val : result2)
  {
      cout << val.first << " : " << val.second << endl;
  }
  

  需要传入的第二个参数是测量的量子态振幅的十进制表示，输出结果如下，左侧是量子态振幅的十进制表示，右边表示复数形式的振幅值：

  0 : (0.0883883,-0.0883883)
  1 : (0.0883883,-0.0883883)
  2 : (0.0883883,-0.0883883)
  

单振幅云计算

• single_amplitude_pmeasure(单振幅概率测量操作) ：

  auto result3 = QCM.single_amplitude_pmeasure(pmeasure_prog, "0");
  cout << "0" << " : " << result3 << endl;
  

  需要传入的第二个参数是测量的振幅（十进制表示），输出结果如下，只会输出一个量子态对应的复数形式的振幅值：

  0 : (0.0883883,-0.0883883)
  

噪声模拟云计算

• noise_measure(噪声虚拟机测量操作) ：

  QCM.set_noise_model(NOISE_MODEL::BIT_PHASE_FLIP_OPRATOR, { 0.01 }, { 0.02 });
  auto result4 = QCM.noise_measure(measure_prog, 100);
  for (auto val : result4)
  {
      cout << val.first << " : " << val.second << endl;
  }
  

  通过 set_noise_model 设置噪声参数，第一个参数是噪声模型，后面分别是单门噪声参数和双门噪声参数，噪声模型的定义如下：

  enum NOISE_MODEL
  {
      DAMPING_KRAUS_OPERATOR,
      DEPHASING_KRAUS_OPERATOR,
      DECOHERENCE_KRAUS_OPERATOR_P1_P2,
      BITFLIP_KRAUS_OPERATOR,
      DEPOLARIZING_KRAUS_OPERATOR,
      BIT_PHASE_FLIP_OPRATOR,
      PHASE_DAMPING_OPRATOR,
      DECOHERENCE_KRAUS_OPERATOR,
      PAULI_KRAUS_MAP,
      KRAUS_MATRIX_OPRATOR,
      MIXED_UNITARY_OPRATOR,
  };
  

  该接口输出结果如下，左侧是量子态的二进制表示，右边表示测量对应的概率：

  000 : 0.10
  001 : 0.08
  010 : 0.13
  011 : 0.08
  100 : 0.20
  101 : 0.23
  110 : 0.08
  111 : 0.10
  

Note

• 使用对应的计算接口时，需要确认当前用户已经开通了该产品，否则可能会导致提交计算任务失败。

• 在噪声模拟时，退相干的单门噪声和双门参数参数分别有3个，不同于其他噪声

• 本源悟源测量操作支持的测量次数范围在1000至10000之间，且目前仅支持6及以下量子比特的量子线路模拟，未来会加入其他的量子芯片，敬请期待。

• 在使用时遇到任何问题，请给我们提交 用户反馈 ，我们看到后会尽快解决你的问题

量子门的有效性

量子门的分类

量子门主要分为单量子门、双量子门和三量子门，根据量子芯片中元数据不同的单量子门或双量子门组合对单量子门和双量子门又分为了不同的类型，下面分别对单量子门和双量子门进行介绍。

单比特逻辑门判断

单量子门可分为四种情况：任意旋转类，双连续类，单连续单离散类，双离散类。下面根据量子芯片的元数据判断单量子门所属类型。

1. 任意旋转类：需要判断元数据提供的单量子门的容器中是否存在 U3 、 U2 的量子门类型，如果存在则是任意旋转类，如果不存在则不是任意旋转类；

2. 双连续类：需要判断元数据提供的单量子门的容器中是否存在 RX+RZ 、 RX+RY 、 RY+RZ 这三种组合，如果存在则是双连续类，如果不存在则不是双连续类；

3. 单连续单离散类：第一步，需要判断元数据提供的单量子门的容器中是否存在 RX 、 RY 、 RZ 这三种量子门；第二步，如果存在 RX，不存在 RY 、 RZ，则查找容器中是否有 Y 、 H 、 Z 量子门中的一种，如果存在则是单连续单离散类，如果不存在则不是单连续单离散类。如果存在 RY，不存在 RX 、 RZ，则查找容器中是否有 X 、 H 、 Z 量子门中的一种，如果存在则是单连续单离散类，如果不存在则不是单连续单离散类。如果存在 RZ ，不存在 RX 、 RY ,则查找容器中是否存在 X 、 H 、 Y 中的一种，如果存在则是单连续单离散类，如果不存在则不是单连续单离散类。

4. 双离散类：如果元数据提供的单量子门的容器中不存在 RX 、 RY 、 RZ 这三种量子门，则判断 H+T 、 X+T 、 Y+T 的组合，如果存在则是双离散类，如果不存在则不是双离散类。

当以上四种情况都不存在时，则当前芯片元数据提供的单逻辑门信息不是有效信息。

双量子门判断

双量子门需要判断元数据提供的双量子门的容器中是否 CNOT 、 SWAP 门，如果存在则元数据可用，如果不存在则元数据不可用。

判断量子门有效性的方法

判断量子门有效性是由 SingleGateTypeValidator 和 DoubleGateTypeValidator 两个类实现的。下面分别对这两个类中的接口介绍。

接口介绍

SingleGateTypeValidator 是验证单量子逻辑门有效性的工具类，使用方式如下：

std::vector<std::string> single_gate;
std::vector<std::string> valid_single_gate; // 有效的量子逻辑门组合会输出到这个容器中
single_gate.push_back("T");
single_gate.push_back("H");
single_gate.push_back("S");
auto single_gate_type = SingleGateTypeValidator::GateType(single_gate, valid_single_gate); // 得到有效的量子逻辑门组合，和有效组合的类型

使用QPanda2封装的接口：

auto single_gate_type = validateSingleQGateType(double_gate, valid_double_gate);

DoubleGateTypeValidator 是验证双量子逻辑门有效性的工具类，使用方式如下：

std::vector<std::string> double_gate;
std::vector<std::string> valid_double_gate; // 有效的量子逻辑门组合会输出到这个容器中
double_gate.push_back("CNOT");
double_gate.push_back("SWAP");
double_gate.push_back("CZ");
auto double_gate_type = DoubleGateTypeValidator::GateType(double_gate, valid_double_gate); // 得到有效的量子逻辑门组合，和有效组合的类型

使用QPanda2封装的接口：

auto double_gate_type = validateDoubleQGateType(double_gate, valid_double_gate);

实例

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    // 单量子门有效性验证
    std::vector<std::string> single_gate;
    std::vector<std::string> valid_single_gate; // 有效的量子逻辑门组合会输出到这个容器中
    single_gate.push_back("T");
    single_gate.push_back("H");
    single_gate.push_back("S");

    // 得到有效的量子逻辑门组合，和有效组合的类型
    auto single_gate_type = validateSingleQGateType(single_gate, valid_single_gate);

    std::cout << "SingleGateTransferType: " << single_gate_type << std::endl;
    for (auto &val : valid_single_gate)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    // 双量子门有效性验证
    std::vector<std::string> double_gate;
    std::vector<std::string> valid_double_gate; // 有效的量子逻辑门组合会输出到这个容器中
    double_gate.push_back("CNOT");
    double_gate.push_back("SWAP");
    double_gate.push_back("CZ");

    // 得到有效的量子逻辑门组合，和有效组合的类型
    auto double_gate_type = validateDoubleQGateType(double_gate, valid_double_gate);

    std::cout << "doubleGateTransferType: " << double_gate_type << std::endl;
    for (auto &val : valid_double_gate)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

运行结果：

SingleGateTransferType: 3
T H
doubleGateTransferType: 0
CNOT

Warning

新版本中接口名有所调整，旧接口 SingleGateTypeValidator::GateType() 和 DoubleGateTypeValidator::GateType() 分别由新接口 validateSingleQGateType() 和 validateDoubleQGateType() 替代。

SingleGateTypeValidator::GateType() 和 DoubleGateTypeValidator::GateType() 将于下版本去除，请读者知悉。

统计量子程序时钟周期

简介

已知每个量子逻辑门在运行时所需时间的条件下，估算一个量子程序运行所需要的时间。每个量子逻辑门的时间设置在项目的元数据配置文件 QPandaConfig.xml 中， 如果未设置则会给定一个默认值，单量子门的默认时间为2，双量子门的时间为5。

配置文件可仿照下面设置

<QGate>
    <SingleGate>
        <Gate time = "2">rx</Gate>
        <Gate time = "2">Ry</Gate>
        <Gate time = "2">RZ</Gate>
        <Gate time = "2">S</Gate>
        <Gate time = "2">H</Gate>
        <Gate time = "2">X1</Gate>
    </SingleGate>
    <DoubleGate>
        <Gate time = "5">CNOT</Gate>
        <Gate time = "5">CZ</Gate>
        <Gate time = "5">ISWAP</Gate>
    </DoubleGate>
</QGate>

接口介绍

QProgClockCycle 类是QPanda 2提供的一个统计量子程序时钟周期的工具类，我们先用QPanda 2构建一个量子程序：

auto qubits = qvm->qAllocMany(4);
auto prog = createEmptyQProg();
prog << H(qubits[0]) << CNOT(qubits[0], qubits[1])
        << iSWAP(qubits[1], qubits[2]) << RX(qubits[3], PI/4);

然后调用 QProgClockCycle 类得到量子程序的时钟周期

QProgClockCycle t(qvm);
t.traversal(prog);
auto time = t.count();

我们还可以使用QPanda2封装的一个接口：

auto time = getQProgClockCycle(prog,qvm);

实例

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine();
    auto qubits = qvm->qAllocMany(4);
    auto prog = createEmptyQProg();

    // 构建量子程序
    prog << H(qubits[0])
        << CNOT(qubits[0], qubits[1])
        << iSWAP(qubits[1], qubits[2])
        << RX(qubits[3], PI/4);

    // 统计量子程序时钟周期
    auto time = getQProgClockCycle(prog, qvm);

    std::cout << "clockCycle : " << time << std::endl;
    destroyQuantumMachine(qvm);

    return 0;
}

运行结果：

clockCycle : 12

逻辑门统计

简介

逻辑门的统计是指统计量子程序、量子线路、量子循环控制或量子条件控制中所有的量子逻辑门（这里也会将测量门统计进去）个数方法。

接口介绍

QGateCounter 类是统计一个量子程序(量子线路、量子循环控制、量子条件控制)中量子逻辑门个数的工具类，我们先用QPanda2构建一个量子程序：

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

QProg prog;
prog << X(qubits[0])
    << Y(qubits[1])
    << H(qubits[0])
    << RX(qubits[0], 3.14)
    << Measure(qubits[1], cbits[0]);

然后调用 QGateCounter 类统计量子逻辑门的个数，

QGateCounter t;
t.traversal(prog);
size_t num = t.count(prog);;

我们还可以使用QPanda2封装的一个接口：

size_t num = getQGateNum(prog);

Note

统计 QCircuit 、 QWhileProg 、QIfProg 中量子逻辑门的个数和 QProg 类似。

实例

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    init();
    auto qubits = qAllocMany(4);
    auto cbits = cAllocMany(4);

    QProg prog;

    // 构建量子程序
    prog << X(qubits[0])
        << Y(qubits[1])
        << H(qubits[0])
        << RX(qubits[0], 3.14)
        << Measure(qubits[1], cbits[0]);

    // 统计逻辑门个数
    size_t num = getQGateNum(prog);

    std::cout << "QGate number: " << num << std::endl;
    finalize();
    return;
}

运行结果：

QGate number: 5

Warning

新版本中接口名有所调整，旧接口 getQGateNumber() 将由 getQGateNum() 替代。

getQGateNumber() 将于下版本去除，请读者知悉。

获取量子线路对应矩阵

接口 getCircuitMatrix 可以获得输入线路的对应矩阵，有3个输出参数，一个量子线路QCircuit(或者Qprog)，另外两个是可选参数：迭代器开始位置和结束位置，用于指定一个要获取对应矩阵信息的线路区间，如果这两个参数为空，代表要获取整个量子线路的矩阵信息。

Note

使用 getCircuitMatrix 需要注意的是量子线路中不能包含测量操作。

实例

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine(QMachineType::CPU);
    auto q = qvm->qAllocMany(2);
    auto c = qvm->cAllocMany(2);

    // 构建量子线路
    QCircuit cir;
    cir << H(q[1])
        << CNOT(q[0], q[1])
        << H(q[1]);

    // 获取线路对应矩阵
    QStat cir_matrix = getCircuitMatrix(cir);

    // 打印矩阵信息
    std::cout << cir_matrix << std::endl;

    destroyQuantumMachine(qvm);
    return 0;
}

具体步骤如下:

1. 首先在主程序中用 initQuantumMachine() 初始化一个量子虚拟机对象，用于管理后续一系列行为

2. 接着用 qAllocMany() 和 cAllocMany()初始化量子比特与经典寄存器数目

3. 然后构建量子线路 cir

4. 最后调用接口 getCircuitMatrix() 输出量子线路的对应矩阵，并打印矩阵

判断量子逻辑门是否匹配量子拓扑结构

每一款量子芯片都有其特殊的量子比特拓扑结构,例如IBM QX3：

从图中可知，量子芯片中的每个量子比特不是两两相连的，不相连的量子比特之间是不能直接执行多门操作的。所以在执行量子程序之前需要先判断量子程序中的双门（多门）操作是否适配量子比特拓扑结构。

接口介绍

isMatchTopology：判断量子逻辑门是否符合量子比特拓扑结构。第一个输入参数是目标量子逻辑门QGate，第二个输入参数是量子比特拓扑结构，返回值为布尔值，表示目标量子逻辑门是否满足量子比特拓扑结构。True为满足，False为不满足。

vector<vector<int>> qubits_topology = { {0,1,1,0},
                                        {1,0,0,1},
                                        {1,0,0,1},
                                        {0,1,1,0} };

bool result = isMatchTopology(CNOT(q[1],q[3]),qubits_topology);

在使用isMatchTopology前需要先构建指定量子芯片的量子比特拓扑结构邻接矩阵qubits_topology。

从以上示例可以看出，qubits_topology有四个量子比特，量子比特拓扑图如下：

CNOT逻辑门操作的是1,3号量子比特，而从图中可以看出1,3号量子比特是相连的，所以得到的结果为true。

获得指定位置的量子逻辑门的相邻量子逻辑门

接口 getAdjacentQGateType 可以获得量子程序中指定位置的量子逻辑门的相邻逻辑门。第一个输入参数为目标量子程序QProg，第二个是目标量子逻辑门在量子程序中的迭代器，第三个输出参数是目标量子逻辑门的相邻量子逻辑门迭代器的集合。

实例

#include "QPanda.h"
USING_QPANDA
int main(void)
{
    auto qvm = initQuantumMachine(QMachineType::CPU);
    auto q = qvm->qAllocMany(4);
    auto c = qvm->cAllocMany(4);
    QProg prog;

    // 构建量子程序
    prog << H(q[0])
        << H(q[1])
        << H(q[2])
        << H(q[3])
        << RX(q[0], PI / 2)
        << CNOT(q[1], q[2])
        << RX(q[1], PI / 2)
        << RX(q[2], PI / 2)
        << RX(q[3], PI / 2)
        << CNOT(q[2], q[3]);

    auto node_iter = prog.getFirstNodeIter();
    std::vector<NodeInfo> node_iter_vector;

    // 获取量子程序中node_iter位置上的的相邻节点
    getAdjacentQGateType(prog, node_iter, node_iter_vector);

    // 打印前后相邻节点类型
    std::cout << "The previous node type : " << node_iter_vector[0].m_node_type << std::endl;
    std::cout << "The node type that follows :" << node_iter_vector[1].m_node_type << std::endl;

    destroyQuantumMachine(qvm);
    return 0;
}

以上实例展示 getAdjacentQGateType 接口的使用方式：

1. 构建一个量子程序prog；

2. 获取prog的第一个量子逻辑门的迭代器node_iter；

3. 调用getAdjacentQGateType接口获取node_iter的相邻逻辑门的迭代器集合。

在使用getAdjacentQGateType接口时，我们需要注意以下几点：

1. 目标量子逻辑门相邻量子逻辑门迭代器的集合永远包含两个元素；第一个元素是前一个量子逻辑门的迭代器，第二个元素是后一个量子逻辑门的迭代器。

2. 如果目标量子逻辑门是量子程序的第一个节点，那么输出的参数目标量子逻辑门相邻量子逻辑门迭代器的集合中则只能获取目标量子逻辑门后一个量子逻辑门的迭代器，集合的第一个元素为空迭代器。

3. 如果目标量子逻辑门是量子程序的最后一个量子逻辑门，那么输出的参数目标量子逻辑门相邻量子逻辑门迭代器的集合中则只能获取目标量子逻辑门前一个量子逻辑门的迭代器，集合的第二个元素为空迭代器。

4. 如果目标量子逻辑门前一个节点是QIf或者QWhile，那么输出的参数目标量子逻辑门相邻量子逻辑门迭代器的集合中则只能获取目标量子逻辑门后一个量子逻辑门的迭代器，集合的第一个元素为空迭代器。

5. 如果目标量子逻辑门后一个节点是QIf或者QWhile，那么输出的参数目标量子逻辑门相邻量子逻辑门迭代器的集合中则只能获取目标量子逻辑门前一个量子逻辑门的迭代器，集合的第二个元素为空迭代器。

6. 如果目标量子逻辑门是QWhile的第一个量子逻辑门，那么输出的参数目标量子逻辑门相邻量子逻辑门迭代器的集合中则只能获取目标量子逻辑门后一个量子逻辑门的迭代器，集合的第一个元素为空迭代器。

7. 如果目标量子逻辑门是QWhile的最后量子逻辑门，那么输出的参数目标量子逻辑门相邻量子逻辑门迭代器的集合中则只能获取目标量子逻辑门前一个量子逻辑门的迭代器，集合的第二个元素为空迭代器。

判断两个量子逻辑门是否可交换位置

接口isSwappable可判断量子程序中两个指定位置的量子逻辑门是否可以交换位置。输入参数一为量子程序QProg，输入参数二，三是需要判断的两个量子逻辑门的迭代器。返回值为布尔值，True表示可交换，False表示不可交换。

实例

以下实例展示isSwappable接口的使用方式：

1. 构建一个量子程序prog；

2. 获取prog的第一个量子逻辑门的迭代器node_iter和最后一个量逻辑门的迭代器last_node_iter；

3. 调用isSwappable接口判断指定位置的两个逻辑门能否交换位置。

#include "QPanda.h"
USING_QPANDA
int main(void)
{
    auto qvm = initQuantumMachine(QMachineType::CPU);
    auto q = qvm->qAllocMany(4);
    auto c = qvm->cAllocMany(4);
    QProg prog;

    // 构建量子程序
    prog << H(q[0])
        << H(q[1])
        << H(q[2])
        << H(q[3])
        << RX(q[0], PI / 2)
        << CNOT(q[1], q[2])
        << RX(q[1], PI / 2)
        << RX(q[2], PI / 2)
        << RX(q[3], PI / 2)
        << CNOT(q[2], q[3]);

    // 获取待判断的节点
    auto node_iter = prog.getFirstNodeIter();
    auto last_node_iter = prog.getLastNodeIter();

    // 判断节点是否可交换
    bool result = isSwappable(prog, node_iter, last_node_iter);

    if (result)
        std::cout << "is  swappable! " << std::endl;
    else
        std::cout << "is not swappable! " << std::endl;

    destroyQuantumMachine(qvm);
    return 0;
}

判断逻辑门是否属于量子芯片支持的量子逻辑门集合

量子芯片支持的量子逻辑门集合可在元数据配置文件QPandaConfig.xml 中配置。如果我们没有设置配置文件，QPanda会默认设置一个默认量子逻辑门集合。

默认集合如下所示：

single_gates.push_back("RX");
single_gates.push_back("RY");
single_gates.push_back("RZ");
single_gates.push_back("X1");
single_gates.push_back("H");
single_gates.push_back("S");

double_gates.push_back("CNOT");
double_gates.push_back("CZ");
double_gates.push_back("ISWAP");

配置文件可仿照下面设置:

<QGate>
    <SingleGate>
        <Gate time = "2">rx</Gate>
        <Gate time = "2">Ry</Gate>
        <Gate time = "2">RZ</Gate>
        <Gate time = "2">S</Gate>
        <Gate time = "2">H</Gate>
        <Gate time = "2">X1</Gate>
    </SingleGate>
    <DoubleGate>
        <Gate time = "5">CNOT</Gate>
        <Gate time = "5">CZ</Gate>
        <Gate time = "5">ISWAP</Gate>
    </DoubleGate>
</QGate>

从上面的示例中我们可以得到，量子芯片支持RX，RY，RZ，S，H，X1，CNOT，CZ，ISWAP门。在配置文件配置完成后，我们可以调用接口isSupportedGateType，判断逻辑门是否属于量子芯片支持的量子逻辑门集合。isSupportedGateType接口只有一个参数：目标量子逻辑门；

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine();
    auto q = qvm->qAllocMany(5);
    QProg prog;

    // 构建待判断的逻辑门
    prog << H(q[1]);

    // 判断逻辑门类型是否支持
    bool result = isSupportedGateType(prog.getFirstNodeIter());

    if (result)
        std::cout << "Gate type is supported !";
    else
        std::cout << "Gate type is not supported !";

    destroyQuantumMachine(qvm);
    return 0;
}

Note

用户可通过如下链接地址获取默认配置文件 QPandaConfig.xml , 将该默认配置文件放在执行程序同级目录下，可执行程序会自动解析该文件。

量子线路字符画

接口 draw_qprog() 可以将输入的量子程序转换为字符画并输出到控制台同时将字符画信息保存到文件（QCircuitTextPic.txt，该接口会在当前程序运行目录下创建该txt文件，该文件用utf8编码，并覆盖之前数据）， 接口详细说明如下:

/**
* @brief output a quantum prog/circuit to console by text-picture(UTF-8 encode),
         and will save the text-picture in file named QCircuitTextPic.txt in the same time in current path.
* @param[in] prog  the source prog
* @param[in] itr_start The start pos, default is the first node of the prog
* @param[in] itr_end The end pos, default is the end node of the prog
* @return the output string
* @ Note: All the output characters are UTF-8 code.
*/
std::string draw_qprog(QProg &prog, const NodeIter itr_start = NodeIter(), const NodeIter itr_end = NodeIter());

实例

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine(QMachineType::CPU);
    auto q = qvm->qAllocMany(3);
    auto c = qvm->cAllocMany(3);
    QProg prog;
    QCircuit cir1, cir2;

    // 构建量子程序
    auto gate = S(q[1]);
    gate.setDagger(true);
    cir1 << H(q[0]) << S(q[2]) << CNOT(q[0], q[1]) << CZ(q[1], q[2]) << gate;
    cir1.setDagger(true);
    cir2 << cir1 << CU(1, 2, 3, 4, q[0], q[2]) << S(q[2]) << CR(q[2], q[1], PI / 2);
    cir2.setDagger(true);
    prog << cir2 << MeasureAll(q, c);

    // 量子程序字符画
    std::string text_picture = draw_qprog(prog);

    // 打印字符画
    std::cout << text_picture << std::endl;

    destroyQuantumMachine(qvm);
    return 0;
}

以上示例演示了draw_qprog这个接口的使用方法，上述代码的输出结果如下：

在实际使用过程中，为了方便调用，我们重载了标准输出std::cout，所以以下两部分代码是等价的：

//普通方法打印字符画
string text_picture = draw_qprog(prog);
cout << text_picture << endl;

//通过重载cout，进行字符画打印
cout << prog << endl;

用户在实际使用过程中，也可以通过传入迭代器参数，输出某个量子程序中指定程序段的字符画，我们可以将上述示例代码中，字符画输出部分做如下修改：

auto itr1 = cir1.getFirstNodeIter();
auto itr2 = cir1.getLastNodeIter();

string text_picture = draw_qprog(prog, itr1, itr2);
cout << "draw_qprog:" << endl << text_picture << endl;

上述代码段中，在打印线路字符画时，指定了两个迭代器itr1, itr2，最终输出的应该只是子线路cir1的字符画结果。用户可自行替换上述代码段到前面的示例程序中，运行查看结果，这里不再赘述。

量子体积

简介

量子体积（Quantum Volume），是一个用于评估量子计算系统性能的协议。它表示可以在系统上执行的最大等宽度深度的随机线路。量子计算系统的操作保真度越高，关联性越高，有越大的校准过的门操作集合便会有越高的量子体积。量子体积与系统的整体性能相关联，即与系统的整体错误率，潜在的物理比特关联和门操作并行度相联系。总的来说，量子体积是一个用于近期整体评估量子计算系统的一个实用方法，数值越高，系统整体错误率就越低，性能就越好。

测量量子体积的标准做法就是对系统使用规定的量子线路模型执行随机的线路操作，尽可能地将比特纠缠在一起，然后再将实验得到的结果与模拟的结果进行比较。按要求分析统计结果。

量子体积被定义为指数形式：

\[V_Q=2^n\]

，其中n表示在给定比特数目m（m大于n）和完成计算任务的条件下，系统操作的最大逻辑深度，如果芯片能执行的最大逻辑深度n大于比特数m，那么系统的量子体积就是

\[2^m\]

接口说明

calculate_quantum_volume 输入参数分别噪声虚拟机或者量子云机器，待测量的量子比特，随机迭代次数，测量次数 。输出为 size_t 数据，为量子体积大小。

实例

#include "QPanda.h"
USING_QPANDA
int main()
{
    // 构建噪声虚拟机，设置噪声参数
    auto qvm = new NoiseQVM();
    qvm->init();
    qvm->set_noise_model(NOISE_MODEL::DEPOLARIZING_KRAUS_OPERATOR, CZ_GATE, 0.005);

    // 同样可以申请云计算机器（采用真实芯片），采用真实芯片要考虑芯片构造
    //auto qvm = new QCloudMachine();
    //qvm->init("898D47CF515A48CEAA9F2326394B85C6")

    // 构建待测量的量子比特组合， 这里比特组合为2组，其中 量子比特3、4为一组；量子比特2，3，5为一组
    std::vector <std::vector<int> >qubit_lists = { {3,4}, {2,3,5} };

    // 设置随机迭代次数
    int ntrials = 100;

    // 设置测量次数,即真实芯片或者噪声虚拟机shots数值
    int shots = 4000;

    // 测量量子体积
    auto qv_result = calculate_quantum_volume(qvm, qubit_lists, ntrials, shots);

    // 调整噪声虚拟机参数，数值会根据噪声数值大小而受到影响，噪声越大，qv数值越小。
    std::cout << "Quantum Volume : " << qv_result << std::endl;

    qvm->finalize();
    delete qvm;
    return 0;
}

运行结果：

Quantum Volume ： 8

随机基准

简介

随机基准测试（RB）是使用随机化方法对量子门进行基准测试。由于完整的过程层析成像对于大型系统是不可行的，因此越来越关注可扩展方法， 以部分表征影响量子系统的噪声。在[1]中提出了一种可扩展的、鲁棒的算法（n个量子位组成的系统）， 使用随机技术通过单个参数对整个Clifford门进行基准测试的鲁棒算法。

接口说明

single_qubit_rb 的输入参数分别噪声虚拟机或者量子云机器，待测量的量子比特，随机线路clifford门集的不同数量组合、随机线路的数量、测量次数、验证基本逻辑门（默认无），输出为std::map 数据， 关键值为clifford门集数量，数值对应符合期望概率的大小。

double_qubit_rb 的输入参数分别噪声虚拟机或者量子云机器，待测量的量子比特0，待测量的量子比特1，随机线路clifford门集的不同数量组合、随机线路的数量、测量次数、验证基本逻辑门（默认无）输出为std::map 数据， 关键值为clifford门集数量，数值对应符合期望概率的大小。

实例

#include "QPanda.h"
USING_QPANDA
int main()
{
    // 构建噪声虚拟机，以及设置参数
    auto qvm = new NoiseQVM();
    qvm->init();
    qvm->set_noise_model(NOISE_MODEL::DEPOLARIZING_KRAUS_OPERATOR, CZ_GATE, 0.005);
    qvm->set_noise_model(NOISE_MODEL::DEPOLARIZING_KRAUS_OPERATOR, PAULI_Y_GATE, 0.005);

    // 同样可以申请云计算机器（采用真实芯片）
    //auto qvm = new QCloudMachine();
    //qvm->init("898D47CF515A48CEAA9F2326394B85C6")

    auto qv = qvm->qAllocMany(4);

    // 设置随机线路中clifford门集数量
    std::vector<int > range = { 5,10,15 };

    // 测量单比特随机基准
    std::map<int, double> res = single_qubit_rb(qvm, qv[0], range, 10, 1000);

    // 同样可以测量两比特随机基准
    //std::map<int, double> res = double_qubit_rb(qvm, qv[0], qv[1], range, 10, 1000);

    // 对应的数值随噪声影响，噪声数值越大，所得结果越小，且随clifford门集数量增多，结果数值越小。
    for (auto it : res)
    {
        std::cout << it.first << "  :  " << it.second << std::endl;
    }

    qvm->finalize();
    delete qvm;
    return 0;
}

运行结果：

5   :  0.9998
10  :  0.9984
15  :  0.998

交叉熵基准

简介

交叉熵基准测试（xeb）是一种通过应用随机电路并测量观察到的位串测量值与从模拟获得的这些位串的预期概率之间的交叉熵来评估门性能的方法。

接口说明

double_gate_xeb 输入参数分别噪声虚拟机或者量子云机器、待测量的量子比特0、待测量的量子比特1、线路不同层数、随机线路的数量、测量次数、验证双门类型（默认CZ门）。 输出为 std::map 数据，关键值为线路层数，数值对应符合期望概率的大小。

实例

#include "QPanda.h"
USING_QPANDA
using namespace std;
int main()
{
    // 创建噪声虚拟机
    auto qvm = new NoiseQVM();
    qvm->init();

    // 同样可以申请云计算机器（采用真实芯片）
    //auto qvm = new QCloudMachine();
    //qvm->init("898D47CF515A48CEAA9F2326394B85C6")

    auto qv = qvm->qAllocMany(4);

    // 设置噪声参数
    std::vector<QVec> qvs = { { qv[0], qv[1] } };
    qvm->set_noise_model(DEPOLARIZING_KRAUS_OPERATOR, CZ_GATE, 0.1, qvs);

    // 设置不同层数组合
    std::vector<int> range = { 2,4,6,8,10 };
    auto res = double_gate_xeb(qvm, qv[0], qv[1], range, 10, 1000, CZ_GATE);

    // 对应的数值随噪声影响，噪声数值越大，所得结果越小，且层数增多，结果数值越小。
    for (auto it : res)
    {
        std::cout << it.first << "  :  " << it.second << std::endl;
    }
    qvm->finalize();
    delete qvm;
    return 0;
}

运行结果：

2   :  0.963627
4   :  0.914385
6   :  0.752838
8   :  0.722809
10  :  0.742715

量子程序转化QASM

---

通过该功能模块，你可以解析通过QPanda2构建的量子程序，将其中包含的量子比特信息以及量子逻辑门操作信息提取出来，得到按固定格式存储的QASM指令集。

QASM介绍

---

QASM(Quantum Assembly Language)是IBM公司提出的量子汇编语言，与 OriginIR介绍 中的语法规则类似，一段QASM代码如下所示：

OPENQASM 2.0;
include "qelib1.inc";
qreg q[10];
creg c[10];

x q[0];
h q[1];
tdg q[2];
sdg q[2];
cx q[0],q[2];
cx q[1],q[4];
u1(pi) q[0];
u2(pi,pi) q[1];
u3(pi,pi,pi) q[2];
cz q[2],q[5];
ccx q[3],q[4],q[6];
cu3(pi,pi,pi) q[0],q[1];
measure q[2] -> c[2];
measure q[0] -> c[0];

需要注意的是，QASM的语法格式与OriginIR形相似而神不同，主要区别有以下几点:

• OriginIR对于需要进行转置共轭操作的量子逻辑门与量子线路，需要将目标置于DAGGER与ENDAGGER语句之间，而QASM会直接进行转化。

• OriginIR支持对量子逻辑门与量子线路施加控制操作，而QASM不支持，在对量子程序转化QASM指令集之前，会对其中包含的控制操作进行分解。

关于QASM更多详细信息的介绍、使用与体验请参考 IBM Q Experience量子云平台

QPanda2提供了QASM转换工具接口 std::string convert_qprog_to_qasm(QProg &, QuantumMachine*) 该接口使用非常简单，具体可参考下方示例程序。

实例

---

下面的例程通过简单的接口调用演示了量子程序转化QASM指令集的过程

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine();

    auto prog = createEmptyQProg();
    auto cir = createEmptyCircuit();

    auto q = qvm->qAllocMany(6);
    auto c = qvm->cAllocMany(6);

    // 构建量子程序
    cir << Y(q[2]) << H(q[2]);
    cir.setDagger(true);
    auto h1 = H(q[1]);
    h1.setDagger(true);
    prog << H(q[1])
         << X(q[2])
         << h1
         << RX(q[1], 2 / PI)
         << cir
         << CR(q[1], q[2], PI / 2)
         <<MeasureAll(q,c);

    // 量子程序转换QASM，并打印QASM
    std::cout << convert_qprog_to_qasm(prog,qvm);

    destroyQuantumMachine(qvm);
    return 0;
}

具体步骤如下:

• 首先在主程序中用 initQuantumMachine() 初始化一个量子虚拟机对象，用于管理后续一系列行为

• 接着用 qAllocMany() 和 cAllocMany() 初始化量子比特与经典寄存器数目

• 然后调用 createEmptyQProg() 构建量子程序

• 最后调用接口 convert_qprog_to_qasm 输出QASM指令集并用 destroyQuantumMachine 释放系统资源

运行结果如下：

OPENQASM 2.0;
include "qelib1.inc";
qreg q[6];
creg c[6];
h q[1];
x q[2];
h q[1];
rx(0.636620) q[1];
h q[2];
y q[2];
rz(-0.785398) q[2];
cx q[1],q[2];
rz(-0.785398) q[2];
cx q[1],q[2];
rz(1.570796) q[2];
rx(1.570796) q[1];
ry(-0.785398) q[1];
rx(-1.570796) q[1];
measure q[0] -> c[0];
measure q[1] -> c[1];
measure q[2] -> c[2];
measure q[3] -> c[3];
measure q[4] -> c[4];
measure q[5] -> c[5];

Warning

新增接口 convert_qprog_to_qasm() ，与老版本接口 transformQProgToQASM() 功能相同。

QASM转化为量子程序

---

通过该功能模块，你可以解析QASM文本文件，将其中的量子逻辑门操作信息提取出来，得到QPanda 2内部可操作的量子程序。

QASM介绍

---

QASM的书写格式规范与例程可以参考量子程序转化QASM模块中的 QASM介绍 部分。

QPanda 2提供了QASM文件转换工具接口 convert_qasm_to_qprog() 该接口使用非常简单，具体可参考下方示例程序。

实例

---

接下来通过简单的接口调用演示了QASM转化量子程序的过程

#include "QPanda.h"
USING_QPANDA

int main()
{
    // 编写QASM文件
    std::string filename = "testfile.txt";
    std::ofstream os(filename);
    os << R"(// test QASM file
        OPENQASM 2.0;
        include "qelib1.inc";
        qreg q[3];
        creg c[3];
        x q[0];
        x q[1];
        z q[2];
        h q[0];
        tdg q[1];
        measure q[0] -> c[0];
        measure q[1] -> c[1];
        measure q[2] -> c[2];
        )";

    os.close();

    auto machine = initQuantumMachine(QMachineType::CPU);
    QVec out_qv;
    std::vector<ClassicalCondition> out_cv;

    // QASM转换量子程序
    QProg out_prog = convert_qasm_to_qprog(filename, machine, out_qv, out_cv);

    // 量子程序转换QASM，打印并对比转换结果
    std::cout << convert_qprog_to_qasm(out_prog, machine) << std::endl;
    destroyQuantumMachine(machine);
    return 0;
}

具体步骤如下:

• 首先编写QASM，并将其保存到指定文件中

• 接着在主程序中用 initQuantumMachine() 初始化一个量子虚拟机对象，用于管理后续一系列行为

• 然后调用 convert_qasm_to_qprog() 转化

• 最后调用 convert_qprog_to_qasm() 接口，把量子程序转为QASM，通过比较输入和生成的QASM是否相同，判断QASM是否正确转换成量子程序，并且用 destroyQuantumMachine() 释放系统资源

运行结果如下：

OPENQASM 2.0;
include "qelib1.inc";
qreg q[3];
creg c[3];
x q[0];
x q[1];
z q[2];
h q[0];
tdg q[1];
measure q[0] -> c[0];
measure q[1] -> c[1];
measure q[2] -> c[2];

Note

对于暂不支持的操作类型，可能会在QASM转化成量子程序的过程中发生错误。

量子程序转化为Quil

简介

Quil可以从一个很低级的层次直接描述量子程序、量子算法，它的地位类似于经典计算机中的硬件描述语言或者汇编语言。Quil基本采用“指令+参数列表”的设计方法。一个简单的量子程序例子如下：

X 0
Y 1
CNOT 0 1
H 0
RX(-3.141593) 0
MEASURE 1 [0]

• X 的作用是对目标量子比特进行 Pauli-X 门操作。与之类似的关键词有 Y 、Z 、 H 等等。

• Y 的作用是对目标量子比特进行 Pauli-Y 门操作。

• CNOT 的作用是对两个量子比特执行 CNOT 操作。输入参数为控制量子比特序号和目标量子比特序号。

• H 的作用是对目标量子比特进行 Hadamard 门操作。

• MEASURE 的作用对目标量子比特进行测量并将测量结果保存在对应的经典寄存器里面，输入参数为目标量子比特序号和保存测量结果的经典寄存器序号。

上述仅为Quil指令集语法的一小部分， 详细介绍请参考 pyQuil 。

接口介绍

QProgToQuil 类是QPanda2提供的一个将量子程序转换为Quil指令集的工具类，我们先用QPanda2构建一个量子程序：

QProg prog;
auto qubits = qvm->qAllocMany(4);
auto cbits = qvm->cAllocMany(4);

prog << X(qvec[0])
     << Y(qvec[1])
     << H(qvec[0])
     << RX(qvec[0], 3.14)
     << Measure(qvec[1], cvec[0]);

然后调用 QProgToQuil 类实现转化

QProgToQuil t(qvm);
t.transform(prog);
std::string instructions = t.getInsturctions();

我们还可以使用QPanda2封装的一个接口：

std::string instructions = convert_qprog_to_quil(prog, qvm);

实例

#include "QPanda.h"
USING_QPANDA


int main(void)
{
    auto qvm = initQuantumMachine(QMachineType::CPU);
    auto qubits = qvm->qAllocMany(4);
    auto cbits = qvm->cAllocMany(4);
    QProg prog;

    // 构建量子程序
    prog << X(qubits[0])
         << Y(qubits[1])
         << H(qubits[2])
         << RX(qubits[3], 3.14)
         << Measure(qubits[0], cbits[0]);

    // 量子程序转换Quil
    std::string instructions = convert_qprog_to_quil(prog, qvm);
    std::cout << instructions << std::endl;
    destroyQuantumMachine(qvm);
    return 0;
}

运行结果：

X 0
Y 1
H 2
RX(3.140000) 3
MEASURE 0 [0]

Warning

新增接口 convert_qprog_to_quil() ，与老版本接口 transformQProgToQuil() 功能相同。

量子程序序列化

简介

定义一种协议将量子程序序列化为二进制数据，方便量子程序的存储与传输。

接口介绍

QProgStored 类是QPanda2提供的一个将量子程序序列化的工具类，我们先用QPanda2构建一个量子程序：

auto qubits = qvm->qAllocMany(4);
auto cbits = qvm->cAllocMany(4);

QProg prog;
prog << H(qubits[0]) << CNOT(qubits[0], qubits[1])
        << CNOT(qubits[1], qubits[2])
        << CNOT(qubits[2], qubits[3])
        ;

然后调用 QProgStored 类实现序列化

QProgStored t(qvm);
t.transform(prog);
auto instructions = t.getInsturctions();

QPanda2还提供了封装好的接口来实现量子程序序列化，上述的转化代码也可以修改为：

auto instructions = convert_qprog_to_binary(prog, qvm);

此外，QPanda2还提供了将序列化后的量子程序存储到文件中的方法， 现在讲上述量子程序以二进制的方式存储到 QProg.dat 文件中， 可以调用 QProgStored 类中的方法

QProgStored storeProg(qm);
storeProg.transform(prog);
storeProg.store("QProg.dat");

我们还可以使用QPanda2封装的一个接口：

convert_qprog_to_binary(prog, qvm, "QProg.dat");

实例

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine();
    auto qubits = qvm->qAllocMany(4);
    auto cbits = qvm->cAllocMany(4);
    cbits[0].set_val(0);

    // 构建量子程序
    QProg prog;
    prog << H(qubits[0]) << CNOT(qubits[0], qubits[1])
            << CNOT(qubits[1], qubits[2])
            << CNOT(qubits[2], qubits[3]);

    // 量子程序序列化
    auto data = convert_qprog_to_binary(prog, qvm);

    // 将得到的二进制数据以base64的方式编码
    auto base64_data = Base64::encode(data.data(), data.size());
    std::string data_str(base64_data.begin(), base64_data.end());
    std::cout << data_str << std::endl;

    destroyQuantumMachine(qvm);
    return 0;
}

运行结果：

AAAAAAQAAAAEAAAABAAAAA4AAQAAAAAAJAACAAAAAQAkAAMAAQACACQABAACAAMA

Note

二进制数据不能直接输出，以base64的编码格式编码，得到相应的字符串

Warning

新增接口 convert_qprog_to_binary() ，与老版本接口 transformQProgToBinary() 功能相同。

解析量子程序二进制文件

简介

解析 量子程序序列化 方法序列化的量子程序。

接口介绍

QProgDataParse 类是对 量子程序序列化 类序列化的量子程序反序列化， 例如下面的量子程序：

prog << H(qubits[0]) << CNOT(qubits[0], qubits[1])
        << CNOT(qubits[1], qubits[2])
        << CNOT(qubits[2], qubits[3]);

序列化之后经过base64编码之后得到的结果是（具体序列化的方法参照 量子程序序列化）

AAAAAAQAAAAEAAAABAAAAA4AAQAAAAAAJAACAAAAAQAkAAMAAQACACQABAACAAMA

现在就对这个结果反序列化，先讲base64的结果解码成二进制数据：

std::string = "AAAAAAQAAAAEAAAABAAAAA4AAQAAAAAAJAACAAAAAQAkAAMAAQACACQABAACAAMA";
auto data = Base64::decode(data_str.data(), data_str.size());

然后调用 QProgDataParse 类中的函数， 得到反序列化之后的量子程序

QProgDataParse parse(qvm);
parse.load(data);
parse.parse(parseProg);
auto qubits_parse = parse.getQubits();
auto cbits_parse = parse.getCbits();

我们还可以使用QPanda2封装的一个接口：

QVec qubits_parse;
std::vector<ClassicalCondition> cbits_parse;
convert_binary_data_to_qprog(qvm, data, qubits_parse, cbits_parse, parseProg);

实例

#include "QPanda.h"

USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine();
    QProg parseProg;
    QVec qubits_parse;
    std::vector<ClassicalCondition> cbits_parse;

    std::string data_str = "AAAAAAQAAAAEAAAABAAAAA4AAQAAAAAAJAACAAAAAQAkAAMAAQACACQABAACAAMA";

    // base64的方式解码，得到的二进制数据
    auto data = Base64::decode(data_str.data(), data_str.size());

    // 解析二进制数据，得到量子程序
    convert_binary_data_to_qprog(qvm, data, qubits_parse, cbits_parse, parseProg);

    // 概率测量，并返回目标量子比特的概率测量结果，下标为十进制
    auto result_parse = probRunTupleList(parseProg, qubits_parse);

    // 打印测量结果
    for (auto &val : result_parse)
    {
        std::cout << val.first << ", " << val.second << std::endl;
    }

    destroyQuantumMachine(qvm);
    return 0;
}

运行结果：

0, 0.5
15, 0.5
1, 0
2, 0
3, 0
4, 0
5, 0
6, 0
7, 0
8, 0
9, 0
10, 0
11, 0
12, 0
13, 0
14, 0

Note

可以运行出正确的结果说明可以将序列化的量子程序正确的解析出来

Warning

新增接口 convert_binary_data_to_qprog() ，与老版本接口 transformBinaryDataToQProg() 功能相同。

OriginIR转化为量子程序

---

通过该功能模块，你可以解析OriginIR文本文件，将其中的量子逻辑门操作信息提取出来，得到QPanda 2内部可操作的量子程序。

OriginIR

---

OriginIR的书写格式规范与例程可以参考量子程序转化OriginIR模块中的 OriginIR介绍 部分。

QPanda 2提供了OriginIR文件转换工具接口 convert_originir_to_qprog() 该接口使用非常简单，具体可参考下方示例程序。

实例

---

接下来通过简单的接口调用演示了OriginIR转化量子程序的过程

#include "QPanda.h"
USING_QPANDA

int main()
{
    // 编写OriginIR文件
    std::string filename = "testfile.txt";
    std::ofstream os(filename);
    os << R"(QINIT 4
        CREG 4
        DAGGER
        X q[1]
        X q[2]
        CONTROL q[1], q[2]
        RY q[0], (1.047198)
        ENDCONTROL
        ENDDAGGER
        MEASURE q[0], c[0]
        QIF c[0]
        H q[1]
        ELSE
        H q[2]
        RZ q[2], (2.356194)
        CU q[2], q[3], (3.141593, 4.712389, 1.570796, -1.570796)
        CNOT q[2], q[1]
        ENDQIF
        )";

    os.close();

    auto machine = initQuantumMachine(QMachineType::CPU);
    QVec out_qv;
    std::vector<ClassicalCondition> out_cv;

    // OriginIR转换量子程序
    QProg out_prog = convert_originir_to_qprog(filename, machine, out_qv, out_cv);

    // 量子程序转换OriginIR，打印并对比转换结果
    std::cout <<
        convert_qprog_to_originir(out_prog, machine)
        << std::endl;

    destroyQuantumMachine(machine);
    return 0;
}

具体步骤如下:

• 首先编写OriginIR，并将其保存到指定文件中

• 接着在主程序中用 initQuantumMachine() 初始化一个量子虚拟机对象，用于管理后续一系列行为

• 然后调用 convert_originir_to_qprog() 转化

• 最后调用 convert_qprog_to_originir() 接口，把量子程序转为OriginIR，通过比较输入和生成的OriginIR是否相同，判断OriginIR是否正确转换成量子程序，并且用 destroyQuantumMachine() 释放系统资源

运行结果如下：

QINIT 4
CREG 4
DAGGER
X q[1]
X q[2]
CONTROL q[1],q[2]
RY q[0],(1.047198)
ENCONTROL
ENDDAGGER
MEASURE q[0],c[0]
QIF c[0]
H q[1]
ELSE
H q[2]
RZ q[2],(2.356194)
CU q[2],q[3],(3.141593,4.712389,1.570796,-1.570796)
CNOT q[2],q[1]
ENDQIF

Note

对于暂不支持的操作类型，可能会在OriginIR转化成量子程序的过程中发生错误。

Warning

新增接口 convert_originir_to_qprog() ，与老版本接口 transformOriginIRToQProg() 功能相同。

量子程序转化OriginIR

---

通过该功能模块，你可以解析通过QPanda2构建的量子程序，将其中包含的量子比特信息以及量子逻辑门操作信息提取出来，得到按固定格式存储的OriginIR。

OriginIR介绍

---

OriginIR是基于QPanda的量子程序中间表示，对QPanda各种特性的支持有非常重要的作用。OriginIR不仅可以表示绝大部分量子逻辑门类型，表示针对量子线路的dagger操作，为量子线路添加控制比特，还可以支持QPanda独有的Qif、QWhile，可以实现量子程序内嵌经典程序。

OriginIR主要内容有量子比特、经典寄存器、量子逻辑门、转置共轭操作、添加控制比特操作、QIf、QWhile、经典表达式。

量子比特

OriginIR使用QINIT申请量子比特，其格式为QINIT后跟空格+量子比特总数。示例：QINIT6。需要注意的是除注释外QINIT必须出现在OriginIR程序的第一行。 在使用量子比特时，OriginIR使用q[i]表示某个具体的量子比特，此处i为量子比特的编号，i可为无符号数字型常量，也可为变量，同时也可使用c[i]组成的表达式代替，示例：q[1],q[c[0]],q[c[1]+c[2]+c[3]]。

经典寄存器

OriginIR使用CREG申请经典寄存器，其格式为CREG后跟空格+经典寄存器总数。示例：CREG 6； 在使用经典寄存器时，OriginIR使用c[i]表示某个具体的经典寄存器，i为经典寄存器编号,此处i必须为无符号数字型常量；示例：c[1]。

量子逻辑门

OriginIR把量子逻辑门分为以下几个种类：单门无参数型关键字；单门一个参数型；单门两个参数；单门三个参数；单门四个参数；双门无参数；双门一个参数；双门四个参数；三门无参数。 需要注意的是所有单门操作，目标量子比特可以是整个量子比特数组或者单个量子比特。如果是整个量子比特数组时例如：

H q

当量子比特数组大小为3时则等效为：

H q[0]
H q[1]
H q[2]

1、单门无参数型关键字：H、T、S、X、Y、Z、X1、Y1、Z1、I；表示无参数类型的单量子逻辑门；格式为量子逻辑门关键字+空格+目标量子比特。示例：

H q[0]

2、单门一个参数型关键字：RX、RY、RZ、U1；表示有一个参数的单量子逻辑门；格式为量子逻辑门关键字+空格+目标量子比特+逗号+(偏转角度)。示例：

RX q[0],(1.570796)

3、 单门两个参数型关键字：U2、RPhi；表示有两个参数的单量子逻辑门；格式为量子逻辑门关键字+空格+目标量子比特+逗号+（两个偏转角度）。示例：

U2 q[0],(1.570796,-3.141593)

4、 单门三个参数型关键字：U3；表示有三个参数的单量子逻辑门；格式为量子逻辑门关键字+空格+目标量子比特+逗号+（三个偏转角度）。示例：

U3 q[0],(1.570796,4.712389,1.570796)

5、单门四个参数关键字：U4；表示有四个参数的单量子逻辑门；格式为量子逻辑门关键字+空格+目标量子比特+逗号+（四个偏转角度）。示例：

U4 q[1],(3.141593,4.712389,1.570796,-3.141593)

6、双门无参数型关键字：CNOT、CZ、ISWAP、SQISWAP、SWAP；表示无参数的双量子逻辑门；格式为量子逻辑门关键字+空格+控制比特+逗号+目标比特。示例：

CNOT q[0],q[1]

7、双门一个参数型关键字：ISWAPTHETA、CR；表示有一个参数的单量子逻辑门；格式为量子逻辑门关键字+空格+控制比特+逗号+目标比特+逗号+(偏转角度)。示例：

CR q[0],q[1],(1.570796)

8、双门四个参数型关键字：CU；表示有四个参数的单量子逻辑门；格式为量子逻辑门关键字+空格+控制比特+逗号+目标比特+逗号+（四个偏转角度）。示例：

CU q[1],q[3],(3.141593,4.712389,1.570796,-3.141593)

9、 三门无参数型关键字：TOFFOLI；表示无参数的三量子逻辑门；格式为量子逻辑门关键字+空格+控制比特1+逗号+控制比特2+逗号+目标比特。示例：

TOFFOLI  q[0],q[1],q[2]

转置共轭操作

OriginIR中可以对一个或多个量子逻辑门进行转置共轭操作，OriginIR使用DAGGER和 ENDDAGGER关键字定义转置共轭操作的范围，一个DAGGER必须有一个ENDDAGGER匹配，示例：

DAGGER
H q[0]
CNOT q[0],q[1]
ENDDAGGER

添加控制比特操作

OriginIR中可以对一个或多个量子逻辑门添加控制比特，OriginIR使用CONTROL 和 ENDCONTROL关键字定义添加控制比特的范围，CONTROL后跟空格+控制比特列表；示例：

CONTROL q[2],q[3]
H q[0]
CNOT q[0],q[1]
ENDCONTROL

QIF

OriginIR中可以表示量子条件判断程序，它通过QIF、ELSE、ENDIF框定量子条件判断程序的不同分支的范围。QIF必须匹配一个ENDIF，如果QIF有两个分支则需要有ELSE，如果QIF只有一个分支则不需要有ELSE；QIF后跟空格+判断表达式。示例：

1、QIF只有一个条件分支
QIF c[0]==c[1]
H q[0]
CNOT q[0],q[1]
ENDIF

2、QIF有两个条件分支
QIF c[0]+c[1]<5
H q[0]
CNOT q[0],q[1]
ELSE
H q[0]
X q[1]
ENDIF

QWHILE

OriginIR中可以表示量子循环判断程序，它通过QWHILE和ENDQWHILE框定循环判断程序的范围，QWHILE必须匹配一个ENDQWHILE；QWHILE后跟空格+判断表达式。示例：

QWHILE c[0]<5
H q[c[0]]
c[0]=c[0]+1
ENDQWHILE

经典表达式

OriginIR可以在量子程序中嵌入经典表达式，如c[0]==c[1]+c[2]；使用示例：

QWHILE c[0]<5
H q[c[0]]
c[0]=c[0]+1
ENDQWHILE

该示例表示对q[0]~q[4]比特做H门操作；经典表达式中必须是经典寄存器和常量组成的表达式；经典表达式的操作符有

{PLUS , "+"},
{MINUS, "-"},
{MUL, "*"},
{DIV, "/"},
{EQUAL, "==" },
{ NE, "!=" },
{ GT, ">" },
{ EGT, ">=" },
{ LT, "<" },
{ ELT, "<=" },
{AND, "&&"},
{OR, "||"},
{NOT, "!"},
{ASSIGN, "=" }

MEASURE操作

MEASURE表示对指定的量子比特进行测量操作，并把结果保存到指定的经典寄存器中。MEASURE后跟空格+目标量子比特+‘，’+目标经典寄存器。示例：

MEASURE q[0],c[0]

如果申请的量子比特和经典寄存器数量相同。可以使用q表示所有量子比特，c表示所有经典比特。示例：

MEAUSRE q,c

如果量子比特和经典比特数量都为3，则等效为

MEAUSRE q[0],c[0]
MEAUSRE q[1],c[1]
MEAUSRE q[2],c[2]

RESET操作

RESET操作是将操作的量子比特的量子态恢复到0态。格式为RESET+空格+目标量子比特。其中目标量子比特可以是整个量子比特数组或者单个量子比特。 示例：

RESET q

RESET q[1]

BARRIER操作

BARRIER操作是将操作的量子比特进行阻断，防止在线路优化和执行过程。 格式为BARRIER+空格+目标量子比特。其中目标量子比特可以是整个量子比特数组或者单个、多个量子比特。示例：

BARRIER q
BARRIER q[0]
BARRIER q[0],q[1],q[2]

QGATE操作

QGATE为自定义逻辑门操作，可以将多个逻辑门组合成一个新的逻辑门使用。 它通过QGATE和ENDQGATE框定自定义逻辑门的范围。同时需要注意的是，自定义逻辑门的形参名不能与上述相关关键字冲突。示例：

QGATE new_H a
H a
X a
ENDQGATE
new_H q[1]
QGATE new_RX a,(b)
RX a,(PI/2+b)
X a
ENDQGATE
new_RX q[1],(PI/4)

OriginIR程序示例

OPE算法

QINIT 3
CREG 2
H q[2]
H q[0]
H q[1]
CONTROL q[1]
RX q[2],(-3.141593)
ENCONTROL
CONTROL q[0]
RX q[2],(-3.141593)
RX q[2],(-3.141593)
ENCONTROL
DAGGER
H q[1]
CR q[0],q[1],(1.570796)
H q[0]
ENDDAGGER
MEASURE q[0],c[0]
MEASURE q[1],c[1]

QPanda2提供了OriginIR转换工具接口 std::string convert_qprog_to_originir(QProg &, QuantumMachine*) 该接口使用非常简单，具体可参考下方示例程序。

实例

---

下面的例程通过简单的接口调用演示了量子程序转化OriginIR的过程

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine();

    auto prog = createEmptyQProg();
    auto cir = createEmptyCircuit();

    auto q = qvm->qAllocMany(6);
    auto c = qvm->cAllocMany(6);


    cir << Y(q[2]) << H(q[2]);
    cir.setDagger(true);

    auto h1 = H(q[1]);
    h1.setDagger(true);

    // 构建量子程序
    prog << H(q[1])
        << X(q[2])
        << h1
        << RX(q[1], 2 / PI)
        << cir
        << CR(q[1], q[2], PI / 2)
        << MeasureAll(q,c);

    // 量子程序转换QriginIR，并打印OriginIR
    std::cout << convert_qprog_to_originir(prog,qvm) << std::endl;

    destroyQuantumMachine(qvm);
    return 0;
}

具体步骤如下:

• 首先在主程序中用 initQuantumMachine() 初始化一个量子虚拟机对象，用于管理后续一系列行为

• 接着用 qAllocMany() 和 cAllocMany() 初始化量子比特与经典寄存器数目

• 然后调用 createEmptyQProg() 构建量子程序

• 最后调用接口 convert_qprog_to_originir 输出OriginIR字符串，并用 destroyQuantumMachine 释放系统资源

运行结果如下：

QINIT 6
CREG 6
H q[1]
X q[2]
DAGGER
H q[1]
ENDDAGGER
RX q[1],(0.636620)
DAGGER
Y q[2]
H q[2]
ENDDAGGER
CR q[1],q[2],(1.570796)
MEASURE q[0],c[0]
MEASURE q[1],c[1]
MEASURE q[2],c[2]
MEASURE q[3],c[3]
MEASURE q[4],c[4]
MEASURE q[5],c[5]

Note

对于暂不支持的操作类型，OriginIR会显示UnSupported XXXNode，其中XXX为具体的节点类型。

Warning

新增接口 convert_qprog_to_originir() ，与老版本接口 transformQProgToOriginIR() 功能相同。

量子程序匹配拓扑结构

量子计算设备存在量子比特之间的有限连接，使得只能在有限的量子位对上应用两个量子位门。 量子程序应用到目标设备时，必须转换原始的量子程序以适应硬件限制，让双量子比特门中的两个量子比特能够满足物理拓扑结构，从而让双量子位门正常作用； 当前解决方案中多数需要在无法相互作用的两个量子比特间插入额外的SWAP操作，以便将逻辑量子位“移动”到它们可以相互作用的位置。 我们称这种解决方法为量子程序匹配拓扑结构。

接口说明

当前QPanda2版本中存在两种思路的匹配拓扑方法：

• 接口 QProg topology_match(QProg, QVec &, QuantumMachine *, SwapQubitsMethod, ArchType)

  通过采用线路分层以及A*搜索算法，在匹配过程中，让插入的SWAP操作个数近似达到最少，使得算法的整体近似消耗达到最少。 该接口需要传入5个参数，其中分别为 构建的量子程序、使用的量子比特位集合、初始化的虚拟机指针、使用的SWAP操作的方式、拓扑结构的类型； 并且返回映射后的量子程序

• 接口 QProg qcodar_match(QProg, QVec &, QuantumMachine *, QCodarGridDevice, size_t, size_t, size_t)

  通过采用一种上下文敏感和持续时间感知的重映射算法，该算法能够感知门持续时间差和程序上下文，使得它能够从程序中提取更多的并行性， 在不同体系结构的模拟中平均将量子程序的速度提高1.23。并在原始量子噪声模拟器上运行时保持电路的保真度。 该接口需要传入7个参数，其中分别为 构建的量子程序、使用的量子比特位集合、初始化的虚拟机指针、拓扑结构的类型、拓扑结构的宽度、拓扑结构的长度、匹配拓扑运行的次数； 并且返回映射后的量子程序

实例

topology_match 实例

#include "QPanda.h"
using namespace std;
using namespace QPanda;
int  main()
{
    auto qvm = new CPUQVM();
    qvm->init();
    auto q = qvm->qAllocMany(8);
    auto c = qvm->cAllocMany(8);
    auto srcprog = QProg();

    // 构建量子程序
    srcprog << CNOT(q[0], q[3])
        << CNOT(q[0], q[2])
        << CNOT(q[1], q[3])
        << CZ(q[1], q[2])
        << CZ(q[0], q[2])
        << T(q[1])
        << S(q[2])
        << H(q[3]);

    // 对srcprog进行概率测量，得到结果r1
    qvm->directlyRun(srcprog);
    auto r1 = qvm->pMeasureNoIndex(q);

    // 对srcprog进行拓扑匹配，得到匹配ORIGIN_VIRTUAL_ARCH拓扑结构的量子程序outprog
    QProg  outprog = topology_match(srcprog, q, qvm, CNOT_GATE_METHOD, ORIGIN_VIRTUAL_ARCH);

    // 对outprog进行概率测量，得到结果r2
    qvm->directlyRun(outprog);
    auto r2 = qvm->pMeasureNoIndex(q);

    // 对比概率测量结果r1和r2
    int size = std::min(r1.size(), r2.size());
    bool result_equal = true;
    for (int i = 0; i < size; i++)
    {
        if ((fabs(r1[i] - r2[i]) > 1e-6))
            result_equal = false;
    }

    // 如果结果相同，打印结果
    if (result_equal == true)
    {
        std::cout << "The probability measurements are the same, prob list:  " << std::endl;
        for (int i = 0; i < size; i++)
        {
            std::cout << r1[i]  << std::endl;
        }
    }

    qvm->finalize();
    delete qvm;
    return 0 ;
}

具体步骤如下:

• 首先创建量子虚拟机、量子寄存器、经典寄存器

• 编写量子程序 srcprog ，对该量子程序进行概率测量得到结果 r1

• 接着调用 topology_match() 对 srcprog 进行符合特定物理结构的线路映射，得到适配特定物理结构的量子程序 outprog

• 对量子程序 outprog 进行概率测量得到结果 r2

• 由于量子程序映射只是对原线路增加额外的 SWAP 操作，以适配物理拓扑结构，并不影响线路的结构。所以对比结果 r1 和 r2 ，如果结果一致，则线路映射正确。

运行结果如下:

The probability measurements are the same, prob list:
0.5
0
0
0
0
0
0
0
0.5
0
0
0
0
0
0
0

qcodar_match 实例

#include "Core/Core.h"
using namespace std;
using namespace QPanda;
int main()
{
    auto  qvm = new CPUQVM();
    qvm->init();
    auto q = qvm->qAllocMany(4);
    auto cv = qvm->cAllocMany(4);
    QProg srcprog;

    // 构建量子程序
    srcprog << CNOT(q[1], q[3])
        << RX(q[0], PI / 2)
        << CNOT(q[0], q[2])
        << CNOT(q[1], q[3])
        << RY(q[1], -PI / 4)
        << CNOT(q[2], q[0])
        << CZ(q[1], q[2])
        << CNOT(q[1], q[3])
        << RZ(q[2], PI / 6)
        << CNOT(q[2], q[0])
        << RZ(q[0], -PI / 4)
        << CNOT(q[0], q[2])
        << H(q[0])
        << T(q[1])
        << RX(q[1], -PI/4)
        << Y(q[2])
        << Z(q[1])
        ;

    // 对srcprog进行概率测量，得到结果r1
    qvm->directlyRun(srcprog);
    auto r1 = qvm->pMeasureNoIndex(q);

    // 对srcprog进行拓扑匹配，得到匹配SIMPLE_TYPE拓扑结构的量子程序outprog
    QProg outprog = qcodar_match(srcprog, q, qvm, SIMPLE_TYPE, 2, 3, 5);

    // 对outprog进行概率测量，得到结果r2
    qvm->directlyRun(outprog);
    auto r2 = qvm->pMeasureNoIndex(q);

    // 对比概率测量结果r1和r2
    int size = std::min(r1.size(), r2.size());
    bool result_equal = true;
    for (int i = 0; i < size; i++)
    {
        if ((fabs(r1[i] - r2[i]) > 1e-6))
            result_equal = false;
    }

    // 如果结果相同，打印结果
    if (result_equal == true)
    {
        std::cout << "The probability measurements are the same, prob list:  " << std::endl;
        for (int i = 0; i < size; i++)
        {
            std::cout << r1[i] << std::endl;
        }
    }

    qvm->finalize();
    delete qvm;
    return 0;
}

具体步骤如下:

• 首先创建量子虚拟机、量子寄存器、经典寄存器

• 编写量子程序 srcprog ，对该量子程序进行概率测量得到结果 r1

• 接着调用 qcodar_match() 对 srcprog 进行符合特定物理结构的线路映射，得到适配特定物理结构的量子程序 outprog

• 对量子程序 outprog 进行概率测量得到结果 r2

• 由于量子程序映射只是对原线路增加额外的 SWAP 操作，以适配物理拓扑结构，并不影响线路的结构。所以对比结果 r1 和 r2 ，如果结果一致，则线路映射正确。

运行结果如下：

The probability measurements are the same, prob list:
0
0
0
0
0.269995
0.458558
0.0463238
0.0786762
0
0
0
0
0.0134987
0.00794791
0.0786762
0.0463238

量子线路查询替换

在量子计算中，存在一些量子逻辑门或量子线路是可以相互替代的，比如如下替换过程：

H(0)->CNOT(1,0)->H(0) 可以替换为 CZ(1,0)

使用接口介绍

在量子程序中，可能存在多个相同结构的子量子线路或多个相同的量子逻辑门，查询替换量子程序中指定结构的量子线路的功能就是找这些相同结构的子量子线路并把它们替换成目标量子线路。

通过graph_query_replace接口实现该功能，输入参数一为待替换修改的量子程序节点，输入参数二为查询图量子线路节点，输入参数三为替换图量子线路节点，输入参数四为空的量子程序，输入参数五为量子虚拟机指针。

示例

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine();
    auto q = qvm->qAllocMany(5);
    auto c = qvm->cAllocMany(5);

    QProg prog, update_prog;
    QCircuit replace_cir, query_cir;

    // 构建量子程序
    prog << H(q[0])
        << H(q[2])
        << H(q[3])
        << CNOT(q[1], q[0])
        << H(q[0])
        << CNOT(q[1], q[2])
        << H(q[2])
        << CNOT(q[2], q[3])
        << H(q[3]);

    std::cout << "查询替换前：" << std::endl;
    std::cout << convert_qprog_to_originir(prog, qvm) << std::endl;

    // 构建查询线路、 构建替换线路
    query_cir << H(q[0]) << CNOT(q[1], q[0]) << H(q[0]);
    replace_cir << CZ(q[0], q[1]);

    // 搜索量子程序中的查询线路，并用替换线路替代
    graph_query_replace(prog, query_cir, replace_cir, update_prog, qvm);

    std::cout << std::endl;
    std::cout << "查询替换后：" << std::endl;
    std::cout << convert_qprog_to_originir(update_prog, qvm) << std::endl;

    destroyQuantumMachine(qvm);
    return 0;
}

运行结果如下：

查询替换前：
QINIT 5
CREG 5
H q[0]
H q[2]
H q[3]
CNOT q[1],q[0]
H q[0]
CNOT q[1],q[2]
H q[2]
CNOT q[2],q[3]
H q[3]

查询替换后：
QINIT 5
CREG 5
CZ q[0],q[1]
CZ q[2],q[1]
CZ q[3],q[2]

Warning

1. 查询量子线路和替代量子线路控制的量子比特必须一一对应。

2. 查询量子线路和替代量子线路对应的有向无环图必须为连通图。

用I门填充QProg

接口 fill_qprog_by_I 实现用I门填充QProg(量子程序)的功能。

实例

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine(QMachineType::CPU);
    auto q = qvm->qAllocMany(4);
    auto c = qvm->cAllocMany(4);

    QCircuit cir;
    QProg prog;

    // 构建量子程序
    cir << CNOT(q[2], q[3])
        << CU(1, 2, 3, 4, q[1], q[0])
        << (H(q[1]))
        << X(q[2])
        << RZ(q[1], PI / 2)
        << Y(q[2])
        << (CR(q[0], q[3], PI / 2))
        << (S(q[2]))
        << S(q[1])
        << RZ(q[1], PI / 2)
        << Y(q[0])
        << SWAP(q[3], q[1]);

    prog << cir << MeasureAll(q, c);

    // 输出原量子程序
    cout << "The source QProg:" << endl;
    cout << prog << endl;

    // 量子程序填充 I 门
    auto filled_prog = fill_qprog_by_I(prog);

    // 输出填充 I 门的量子程序
    cout << "The filled QProg:" << endl;
    cout << filled_prog << endl;

    destroyQuantumMachine(qvm);
    return 0;
}

以上示例程序演示了 fill_qprog_by_I 接口的使用方法，我们可以看到只需要传入一个QProg类型的参数即可，该接口返回一个填充后的新QProg，输入QProg保持不变。 以上示例程序的字符画展示输出结果如下：

酉矩阵分解

目前，量子计算的算法通常用量子线路表示，量子线路包括量子逻辑门操作。 通常，连续的一段量子线路通常包含几十上百个甚至成千上万个量子逻辑门操作，而量子逻辑门数量或单个量子逻辑门操作的量子比特数越多，计算过程越为复杂，导致量子线路的模拟效率较低，且对硬件资源的占用较多。

算法目标

---

对于上述问题，有必要对量子线路进行一种等价转换，需要减少量子线路中逻辑门的数量， 同时在此基础上，需要确保转换前后整个量子线路对应的酉矩阵完全相同.

算法概述

---

本文介绍的算法是将一个N阶酉矩阵，分解成不超过r = N(N−1)/2个带有少量控制的单量子逻辑门序列，其中N=2^n，分解的产物满足如下等式关系

\(U_rU_{r-1}···U_3U_2U_1U=I_N\)

从而可以得到原矩阵U的分解结果表示

\(U=U_1^{\dagger}U_2^{\dagger}U_3^{\dagger}···U_{r-1}^{\dagger}U_r^{\dagger}\)

使用介绍

---

QPanda2中设计了 matrix_decompose 接口用于进行酉矩阵分解，该接口需要两个参数， 第一个是使用到的所有量子比特，第二个是待分解的酉矩阵，该函数的输出是转换后的量子线路。

实例

---

以下示例展示了部分振幅量子虚拟机接口的使用方式

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto qvm = new CPUQVM();
    qvm->init();
    auto q = qvm->qAllocMany(2);

    QStat source_matrix =
    {
        qcomplex_t(0.974545, 0.002125),qcomplex_t(-0.012681, -0.128788),qcomplex_t(-0.015742, -0.128335),qcomplex_t(-0.020006, -0.128030),
        qcomplex_t(-0.012681, -0.128788),qcomplex_t(0.980870, -0.129132),qcomplex_t(-0.012099, 0.001730),qcomplex_t(-0.016949, -0.063521),
        qcomplex_t(-0.015742, -0.128335),qcomplex_t(-0.012099, 0.001730),qcomplex_t(0.976706, -0.128312),qcomplex_t(-0.023108, -0.110363),
        qcomplex_t(-0.020006, -0.128030),qcomplex_t(-0.016949, -0.063521),qcomplex_t(-0.023108, -0.110363),qcomplex_t(0.974615, -0.127660)
    };

    cout << "source matrix:" << endl << source_matrix << endl;

    QCircuit out_cir = matrix_decompose(q, source_matrix);
    auto circuit_matrix = getCircuitMatrix(out_cir);

    cout << "the decomposed matrix:" << endl << circuit_matrix << endl;

    if (!mat_compare(source_matrix, circuit_matrix, 0.000001))
    {
        cout << "matrix decompose ok !" << endl;
    }
}

上述实例运行的结果如下：

source matrix:

(0.974545, 0.002125)    (-0.012681, -0.128788) (-0.015742, -0.128335) (-0.020006, -0.12803)
(-0.012681, -0.128788)  (0.98087, -0.129132)   (-0.012099, 0.00173)   (-0.016949, -0.063521)
(-0.015742, -0.128335)  (-0.012099, 0.00173)   (0.976706, -0.128312)  (-0.023108, -0.110363)
(-0.020006, -0.12803)   (-0.016949, -0.063521) (-0.023108, -0.110363) (0.974615, -0.12766)

the decomposed matrix:

(0.974545, 0.002125)    (-0.0126815, -0.128788) (-0.0157423, -0.128335)   (-0.0200062, -0.12803)
(-0.012681, -0.128788)  (0.98087, -0.129132)    (-0.0120986, 0.00172999)  (-0.0169483, -0.0635211)
(-0.015742, -0.128335)  (-0.012099, 0.00173007) (0.976706, -0.128312)     (-0.0231076, -0.110363)
(-0.020006, -0.12803)   (-0.016949, -0.0635209) (-0.0231084, -0.110363)   (0.974616, -0.12766)

matrix decompose ok !

从输出的结果可以看出，分解前后的矩阵完全相同，对于一个量子比特数目确定的量子系统， 即使分解前的量子线路含有成千上万个量子逻辑门，该接口可以将分解后的量子线路复杂度控制在合理范围之内， 完全不受到分解前量子线路复杂度的影响，

Note

1. 该接口的输入参数必须为酉矩阵。

2. 通过将分解的结果数量约束在一个限定范围内，有效减少了量子线路中的量子逻辑门数量，极大地提升了量子算法的模拟效率

3. 示例程序中， getCircuitMatrix 接口用于获取一个量子线路对应的矩阵， mat_compare 接口用于对比两个矩阵是否完全相同（在设定的精度范围之内）

泡利算符类

泡利算符是一组三个2×2的幺正厄米复矩阵，又称酉矩阵。我们一般都以希腊字母 \(\sigma\) （西格玛）来表示，记作 \(\sigma_x\) ，\(\sigma_y\) ，\(\sigma_Z\) 。 在 QPanda 中我们称它们为 \(X\) 门，\(Y\) 门，\(Z\) 门。 它们对应的矩阵形式如下表所示。

	\(\sigma_x\)	\(\begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix}\quad\)
	\(\sigma_y\)	\(\begin{bmatrix} 0 & -i \\ i & 0 \end{bmatrix}\quad\)
	\(\sigma_z\)	\(\begin{bmatrix} 1 & 0 \\ 0 & -1 \end{bmatrix}\quad\)

泡利算符的运算规则如下：

1. 泡利算符与自身相乘得到是单位矩阵

\[\sigma_x\sigma_x = I\]

\[\sigma_y\sigma_y = I\]

\[\sigma_z\sigma_z = I\]

2. 泡利算符与单位矩阵相乘，无论是左乘还是右乘，其值不变

\[\sigma_xI = I\sigma_x = \sigma_x\]

\[\sigma_yI = I\sigma_y = \sigma_y\]

\[\sigma_zI = I\sigma_z = \sigma_z\]

3. 顺序相乘的两个泡利算符跟未参与计算的泡利算符是 \(i\) 倍的关系

\[\sigma_x\sigma_y = i\sigma_z\]

\[\sigma_y\sigma_z = i\sigma_x\]

\[\sigma_z\sigma_x = i\sigma_y\]

4. 逆序相乘的两个泡利算符跟未参与计算的泡利算符是 \(-i\) 倍的关系

\[\sigma_y\sigma_x = -i\sigma_z\]

\[\sigma_z\sigma_y = -i\sigma_x\]

\[\sigma_x\sigma_z = -i\sigma_y\]

接口介绍

根据泡利算符的上述性质，我们在 QPanda 中实现了泡利算符类 PauliOperator。我们可以很容易的构造泡利算符类，例如

using namespace QPanda;

// 构造一个空的泡利算符类
PauliOperator p1;

// 2倍的"泡利Z0"张乘"泡利Z1"
PauliOperator p2("Z0 Z1", 2);

// 2倍的"泡利Z0"张乘"泡利Z1" + 3倍的"泡利X1"张乘"泡利Y2"
PauliOperator p3({{"Z0 Z1", 2},{"X1 Y2", 3}});

// 构造一个单位矩阵，其系数为2，等价于PauliOperator p4("", 2);
PauliOperator p4(2);

其中PauliOperator p2(“Z0 Z1”, 2)表示的是 \(2\sigma_{0}^{z}\otimes\sigma_{1}^{z}\)。

Note

构造泡利算符类的时候，字符串里面包含的字符只能是空格、 \(X\) ，\(Y\) ，\(Z\) 中的一个或多个，包含其它字符将会抛出异常。 另外，同一个字符串里面同一泡利算符的比特索引不能相同，例如：PauliOperator(“Z0 Z0”, 2)将会抛出异常。

泡利算符类之间可以做加、减、乘等操作，计算返回结果还是一个泡利算符类。

using namespace QPanda;

PauliOperator a("Z0 Z1", 2);
PauliOperator b("X5 Y6", 3);

PauliOperator plus = a + b;
PauliOperator minus = a - b;
PauliOperator muliply = a * b;

泡利算符类支持打印功能，我们可以将泡利算符类打印输出到屏幕上，方便查看其值。

using namespace QPanda;

PauliOperator a("Z0 Z1", 2);

std::cout << a << std::endl

我们在实际使用的时候，常常需要知道该泡利算符类操作了多少个量子比特，这时候我们通过调用泡利算符类getMaxIndex接口即可得到。 如果是空的泡利算符类调用getMaxIndex接口则返回0，否则返回其最大下标索引值加1的结果。

using namespace QPanda;

PauliOperator a("Z0 Z1", 2);
PauliOperator b("X5 Y6", 3);

// 输出的值为2
std::cout << a.getMaxIndex() << std::endl;
// 输出的值为7
std::cout << b.getMaxIndex() << std::endl;

如果我们构造的的泡利算符类，其中泡利算符的下标索引不是从0开始分配的，例如PauliOperator b(“X5 Y6”, 3)调用getMaxIndex接口返回的使用的比特数是7，其实 只使用了2个比特。我们如何才能返回其真实用到的比特数呢。我们可以调用泡利算符类里面remapQubitIndex接口，它的功能是对泡利算符类中的索引从0比特开始分配映射， 并返回新的泡利算符类，该接口需要传入一个map来保存前后下标的映射关系。

using namespace QPanda;

PauliOperator b("X5 Y6", 3);

std::map<size_t, size_t> index_map;
auto c = b.remapQubitIndex(index_map);

// 输出的值为7
std::cout << b.getMaxIndex() << std::endl;
// 输出的值为2
std::cout << c.getMaxIndex() << std::endl;

实例

以下实例主要是展示 PauliOperator 接口的使用方式.

#include "Operator/PauliOperator.h"

int main()
{
    QPanda::PauliOperator a("Z0 Z1", 2);
    QPanda::PauliOperator b("X5 Y6", 3);

    auto plus = a + b;
    auto minus = a - b;
    auto muliply = a * b;

    std::cout << "a + b = " << plus << std::endl << std::endl;
    std::cout << "a - b = " << minus << std::endl << std::endl;
    std::cout << "a * b = " << muliply << std::endl << std::endl;

    std::cout << "Index : " << muliply.getMaxIndex() << std::endl << std::endl;

    std::map<size_t, size_t> index_map;
    auto remap_pauli = muliply.remapQubitIndex(index_map);

    std::cout << "remap_pauli : " << remap_pauli << std::endl << std::endl;
    std::cout << "Index : " << remap_pauli.getMaxIndex() << std::endl;

    return 0;
}

费米子算符类

我们用如下的记号标识来表示费米子的两个形态， 湮没: \(X\) 表示 \(a_x\) ， 创建: \(X+\) 表示 \(a_x^\dagger\) ， 例如: “1+ 3 5+ 1”则代表 \(a_1^\dagger \ a_3 \ a_5^\dagger \ a_1\)

整理规则如下

1. 不同数字

\["1 \quad 2" = -1 * "2 \quad 1"\]

\["1+ \quad 2+" = -1 * "2+ \quad 1+"\]

\["1+ \quad 2" = -1 * "2 \quad 1+"\]

2. 相同数字

\["1 \quad 1+" = 1 - "1+ \quad 1"\]

\["1+ \quad 1+" = 0\]

\["1 \quad 1" = 0\]

跟 PauliOperator 类似，FermionOperator 类也提供了费米子算符之间加、减和乘的基础的运算操作。通过整理功能可以得到一份有序排列的结果。

实例

#include "Operator/FermionOperator.h"

int main()
{
    QPanda::FermionOperator a("0 1+", 2);
    QPanda::FermionOperator b("2+ 3", 3);

    auto plus = a + b;
    auto minus = a - b;
    auto muliply = a * b;

    std::cout << "a + b = " << plus << std::endl << std::endl;
    std::cout << "a - b = " << minus << std::endl << std::endl;
    std::cout << "a * b = " << muliply << std::endl << std::endl;

    std::cout << "normal_ordered(a + b) = " << plus.normal_ordered() << std::endl << std::endl;
    std::cout << "normal_ordered(a - b) = " << minus.normal_ordered() << std::endl << std::endl;
    std::cout << "normal_ordered(a * b) = " << muliply.normal_ordered() << std::endl << std::endl;

    return 0;
}

优化算法(直接搜索法)

本章节将讲解优化算法的使用，包括 Nelder-Mead 算法跟 Powell 算法，它们都是一种直接搜索算法。我们在 QPanda 中实现了这两个算法，OriginNelderMead 和 OriginPowell ， 这两个类都继承自 AbstractOptimizer 。

接口介绍

我们可以通过优化器工厂生成指定类型的优化器，例如我们指定它的类型为Nelder-Mead

using namespace QPanda;
auto optimizer = OptimizerFactory::makeOptimizer(NELDER_MEAD);

我们需要向优化器注册一个计算损失值的函数和待优化参数。

vector_d init_para{0, 0};
optimizer->registerFunc(myFunc, init_para);

然后设置结束条件，我们可以设置变量及函数值的收敛阈值，函数最大可调用次数，和优化迭代次数。只要满足上述结束条件，则优化结束。

optimizer->setXatol(1e-6);
optimizer->setFatol(1e-6);
optimizer->setMaxFCalls(200);
optimizer->setMaxIter(200);

然后通过exec接口执行优化，通过getResult接口获得优化后的结果。

optimizer->exec();
auto result = optimizer->getResult();

实例

给定一些散列点，我们来拟合一条直线，使得散列点到直线的距离和最小。定义直线的函数的表达式为 y = w*x + b ，接下来我们将通过使用优化算法得到w和b的优化值。 首先定义求期望的函数

QPanda::QResultPair myFunc(QPanda::vector_d para, QPanda::vector_d &grad, int iter, int fcall)
{
    std::vector<double> x = {3.3, 4.4, 5.5, 6.71, 6.93, 4.168, 9.779, 6.182, 7.59,
                2.167, 7.042, 10.791, 5.313, 7.997, 5.654, 9.27, 3.1};

    std::vector<double> y = {1.7, 2.76, 2.09, 3.19, 1.694, 1.573, 3.366, 2.596, 2.53,
                1.221, 2.827, 3.465, 1.65, 2.904, 2.42, 2.94, 1.3};

    std::vector<double> y_;

    for (auto i = 0u; i < x.size(); i++)
    {
        y_.push_back(para[0]*x[i] + para[1]);
    }

    float loss = 0;
    for (auto i = 0u; i < y.size(); i++)
    {
        loss += std::pow(y[i] - y_[i], 2)/y.size();
    }

    return std::make_pair("", loss);
}

我们使用 Nelder-Mead 算法进行优化

#include "Optimizer/AbstractOptimizer.h"
#include "Optimizer/OptimizerFactory.h"
#include <iostream>

int main()
{
    auto optimizer = QPanda::OptimizerFactory::makeOptimizer(QPanda::OptimizerType::NELDER_MEAD);

    QPanda::vector_d init_para{0, 0};
    optimizer->registerFunc(myFunc, init_para);
    optimizer->setXatol(1e-6);
    optimizer->setFatol(1e-6);
    optimizer->setMaxFCalls(200);
    optimizer->setMaxIter(200);
    optimizer->exec();

    auto result = optimizer->getResult();

    std::cout << result.message << std::endl;
    std::cout << "         Current function value: "
        << result.fun_val << std::endl;
    std::cout << "         Iterations: "
        << result.iters << std::endl;
    std::cout << "         Function evaluations: "
        << result.fcalls << std::endl;

    std::cout << "         Optimized para: " << std::endl;
    for (auto i = 0u; i < result.para.size(); i++)
    {
        std::cout << "             " << result.para[i] << std::endl;
    }
}

我们将散列点和拟合的直线进行绘图

变量

变量类是实现符号计算的用户类，用于存储特定混合量子经典网络的变量。 通常任务是优化变量以最小化成本函数。 变量可以是标量，矢量或矩阵。

变量具有树形结构，它可以包含子节点或父节点。 如果变量没有子节点，那么我们称之为叶子节点。 我们可以将变量设置为特定值，另一方面，如果变量的所有叶子节点都已设置了值，我们也可以获得该变量的值。

接口介绍

在QPanda中，我们需要引入 QPanda::Variational 命名空间才能使用变量相关的类。我们可以通过传入一个浮点型的数据来构造一个标量变量， 也可以通过 Eigen 库中的 MatrixXd 类型数据的构造一个矢量或矩阵变量。

using namespace QPanda::Variational;

var const_var(1);

MatrixXd m1(2, 2);
m1 << 1, 2, 3, 4;

MatrixXd m2(2, 2);
m2 << 5, 6, 7, 8;

var var1(m1);
var var2(m2);

Note

在定义变量的时候，可以定义变量的类型是否可以微分，默认情况下我们定义的变量的类型都是不可微分的，不可微分的变量相当于 placeholder。 定义可微分的变量时，需要指定构造函数的第二个参数为true, 例如：var v1(1, true)。

我们可以先定义计算对应的表达式，表达式由变量之间进行加减乘除操作或其它操作组成，表达式也是一个变量。

var v1(10);
var v2(5);

var add = v1 + v2;
var minus = v1 - v2; //var minus(op_type::minus, {v1, v2});
var multiply = v1 * v2;
var divide = v1 / v2;

我们可以在不改变表达式结构的情况下，通过改变某个变量的值，即可得到不同的计算结果。我们可以调用变量的 _eval 接口，来计算该变量当前的值。

var v1(1);
var v2(2);

var add = v1 + v2;

std::cout << add._eval() << std::endl;// 输出为3

MatrixXd m(1, 1);
m << 3;
v1.setValue(m);

std::cout << add._eval() << std::endl;// 输出为5

实例

下面我们将以更多的示例来展示变量类相关接口的使用。

#include "Variational/var.h"

int main()
{
    using namespace QPanda::Variational;

    var const_var(1);

    MatrixXd m1(2, 2);
    m1 << 1, 2, 3, 4;

    MatrixXd m2(2, 2);
    m2 << 5, 6, 7, 8;

    var var1(m1);
    var var2(m2);

    var sum = var1 + var2;
    var minus(op_type::minus, {var2, var1});
    var multiply = var1 * var2;

    MatrixXd dx = MatrixXd::Ones(2, 2);

    std::cout << "const_var: " << std::endl << const_var.getValue() << std::endl;
    std::cout << "var1: " << std::endl << var1.getValue() << std::endl;
    std::cout << "var2: " << std::endl << var2.getValue() << std::endl;
    std::cout << "sum: "  << std::endl << sum._eval() << std::endl;
    std::cout << "    op_type: " << int(sum.getOp()) << std::endl;
    std::cout << "    NumOpArgs: " << int(sum.getNumOpArgs()) << std::endl;
    std::cout << "minus: "  << std::endl << minus._eval() << std::endl;
    std::cout << "    op_type: " << int(minus.getOp()) << std::endl;
    std::cout << "    NumOpArgs: " << int(minus.getNumOpArgs()) << std::endl;
    std::cout << "multiply: "  << std::endl << multiply._eval() << std::endl;
    std::cout << "    op_type: " << int(multiply.getOp()) << std::endl;
    std::cout << "    NumOpArgs: " << int(multiply.getNumOpArgs()) << std::endl;
    std::cout << "Derivative multipy to var1:" <<std::endl<< multiply._back_single(dx, 0)<<std::endl;
    std::cout << "Derivative multipy to var2:" <<std::endl<< multiply._back_single(dx, 1)<<std::endl;


    MatrixXd m3(2, 2);
    m3 << 4, 3, 2, 1;
    var1.setValue(m3);

    std::cout << "sum: "  << std::endl << sum._eval() << std::endl;
    std::cout << "minus: "  << std::endl << minus._eval() << std::endl;
    std::cout << "multiply: "  << std::endl << multiply._eval() << std::endl;
    std::cout << "matrix_var1 UseCount: " << var1.getUseCount() << std::endl;

    return 0;
}

运算符

VQNet包含许多类型的运算符， 这些运算符可以操作变量或占位符。 其中，一些运算符是经典运算符，例如加，减，乘，除，指数，对数和点乘等。 VQNet还包含来自经典机器学习中所有常见操作符。

VQNet还包含有量子运算符，它们是vqp和qop pmeasure。 另外，qop和qop pmeasure与量子计算机芯片有关，使用它们需要量子环境。 为此，我们需要在使用这两个运算符时需要添加额外的参数。 一般来说，我们需要添加量子机器的引用和申请的量子比特来提供量子环境。

VQNet定义了如下表所示运算符，所有运算符返回的都是类型为 var 的变量。

运算符	描述
plus	加。示例：a + b，其中a和b都是类型为 var 的变量。
minus	减。示例：a - b。
multiply	乘。示例：a * b。
divide	除。示例：a / b。
exponent	指数。示例：exp(a)。
log	对数。示例：log(a)。
polynomial	幂。示例：poly(a, 2)。
dot	矩阵点乘。示例：dot(a, b)。
inverse	求矩阵逆。示例：inverse(a)。
transpose	矩阵转置。示例：transpose(a)。
sum	矩阵求和。示例：sum(a)。
stack	矩阵按列(axis = 0)或行(axis = 1)方向进行拼接。示例：stack(axis, a, b, c)。
subscript	下标操作。示例：a[0]。
qop	量子操作，它将 VQC 和几个哈密顿量作为输入，并输出输入哈密顿量的期望。 示例：如果w表示 VQC 的变量，qop(VQC(w)，Hamiltonians，[量子环境])。
qop_pmeasure	量子操作，它类似于qop。 qop_pmeasure的输入包括VQC，待测量的量子位和 分量。它可以计算由待测量的量子比特构成的子空间中的所有投影状态的概率， 并返回其中的一些。分量存储目标投影状态的标签。 很明显，任何投射状态的 概率都可以看作哈密顿量的期望，所以qop_pmeasure是qop的一个特例。 示例：qop_pmeasure(VQC(w), components, [量子环境])。
sigmoid	激活函数。示例：sigmoid(a)。
softmax	激活函数。示例：softmax(a)。
cross_entropy	交叉熵。示例：crossEntropy(a, b)。
dropout	dropout函数。示例：dropout(a, b)。

可变量子逻辑门

要在VQNet中使用量子操作 qop 或 qop_pmeasure ，就必须要包含可变量子线路(VQC)，而可变量子逻辑门则是构成 VQC 的基本单位。 可变量子逻辑门(VariationalQuantumGate，别名: VQG)，内部维护着一组变量参数以及一组常量参数。 在构造 VQG 的时候只能对其中一组参数进行赋值。若含有一组常量参数，则可以通过 VQG 生成含确定参数的普通量子逻辑门, 若含有变量参数，则可以动态修改参数值，并生成对应的参数的普通量子逻辑门。

目前在QPanda::Variational中定义了如下可变量子逻辑门，它们都继承自 VQG 。

VQG	别名
VariationalQuantumGate_H	VQG_H
VariationalQuantumGate_RX	VQG_RX
VariationalQuantumGate_RY	VQG_RY
VariationalQuantumGate_RZ	VQG_RZ
VariationalQuantumGate_CNOT	VQG_CNOT
VariationalQuantumGate_CZ	VQG_CZ

接口介绍

我们可以通过可变量子逻辑门的别名，来使用可变量子逻辑门。我们可以向需要传入参数的可变量子逻辑门中传入变量参数， 例如我们对可变量子逻辑门RX和RY传入变量参数x和y。也可以对可变量子逻辑门传入常量参数，例如RZ我们传入了一个常量参数0.12。 我们可以通过修改变量的参数，从而来改变可变量子逻辑门中的参数。

MatrixXd m1(1, 1);
MatrixXd m2(1, 1);
m1(0, 0) = 1;
m2(0, 0) = 2;

var x(m1);
var y(m2);

VQC vqc;
vqc.insert(VQG_H(q[0]));
vqc.insert(VQG_RX(q[0], x));
vqc.insert(VQG_RY(q[1], y));
vqc.insert(VQG_RZ(q[0], 0.12));
vqc.insert(VQG_CZ(q[0], q[1]));
vqc.insert(VQG_CNOT(q[0], q[1]));

QCircuit circuit1 = vqc.feed();

m1(0, 0) = 3;
m2(0, 0) = 4;

x.setValue(m1);
y.setValue(m2);

QCircuit circuit2 = vqc.feed();

实例

#include "QPanda.h"
#include "Variational/var.h"

int main()
{
    using namespace QPanda;
    using namespace QPanda::Variational;

    constexpr int qnum = 2;

    QuantumMachine *machine = initQuantumMachine(CPU);
    auto q = machine->qAllocMany(qnum);

    MatrixXd m1(1, 1);
    MatrixXd m2(1, 1);
    m1(0, 0) = 1;
    m2(0, 0) = 2;

    var x(m1);
    var y(m2);

    VQC vqc;
    vqc.insert(VQG_H(q[0]));
    vqc.insert(VQG_RX(q[0], x));
    vqc.insert(VQG_RY(q[1], y));
    vqc.insert(VQG_RZ(q[0], 0.123));
    vqc.insert(VQG_CZ(q[0], q[1]));
    vqc.insert(VQG_CNOT(q[0], q[1]));

    QCircuit circuit = vqc.feed();
    QProg prog;
    prog << circuit;

    std::cout << convert_qprog_to_originir(prog, machine) << std::endl << std::endl;

    m1(0, 0) = 3;
    m2(0, 0) = 4;

    x.setValue(m1);
    y.setValue(m2);

    QCircuit circuit2 = vqc.feed();
    QProg prog2;
    prog2 << circuit2;

    std::cout << convert_qprog_to_originir(prog2,machine) << std::endl;

    return 0;
}

可变量子线路

在 VQNet 中量子操作 qop 和 qop_pmeasure 都需要使用可变量子线路作为参数。 可变量子线路(VariationalQuantumCircuit，别名 VQC)是用来存储含有可变参数的量子线路信息， VQC 主要由可变量子逻辑门（VQG）组成。使用时可以向 VQC 插入普通量子逻辑门，或者普通量子线路、以及 VQG 或另外一个 VQC， 在插入普通量子逻辑门或普通量子线路时，其在内部将普通量子逻辑门转换成一组含有固定参数的 VQG。 变量可以和 VQC 中的不同 VQG 相关，VQC 对象会保存变量和 VQG 之间的映射。

接口介绍

量子程序 QProg 无法直接加载可变量子线路，但是我们可以通过调用可变量子线路的 feed 接口来生成一个普通量子线路。

MatrixXd m1(1, 1);
MatrixXd m2(1, 1);
m1(0, 0) = 1;
m2(0, 0) = 2;

var x(m1);
var y(m2);

VQC vqc;
vqc.insert(VQG_H(q[0]));
vqc.insert(VQG_RX(q[0], x));
vqc.insert(VQG_RY(q[1], y));

QCircuit circuit = vqc.feed();
QProg prog;
prog << circuit;

我们可以调用 get_var_in_which_gate 接口来获取到指定变量在可变量子线路中对应的可变量子逻辑门。 我们可以通过向feed接口传入变量对应的可变量子逻辑门，变量在可变量子逻辑门中的索引位置，以及偏移值，来改变指定可变量子逻辑门中变量参数的偏移值。

auto gates = vqc.get_var_in_which_gate(x);

int pos = shared_ptr<VariationalQuantumGate>(gates[0])->var_pos(x);

vector<tuple<weak_ptr<VariationalQuantumGate>, size_t, double>> plus;
plus.push_back(make_tuple(gates[0], pos, 3));

QCircuit circuit2 = vqc.feed(plus);

实例

#include "QPanda.h"
#include "Variational/var.h"

int main()
{
    using namespace std;
    using namespace QPanda;
    using namespace QPanda::Variational;

    constexpr int qnum = 2;

    QuantumMachine *machine = initQuantumMachine(CPU);
    auto q = machine->qAllocMany(qnum);

    MatrixXd m1(1, 1);
    MatrixXd m2(1, 1);
    m1(0, 0) = 1;
    m2(0, 0) = 2;

    var x(m1);
    var y(m2);

    VQC vqc;
    vqc.insert(VQG_H(q[0]));
    vqc.insert(VQG_RX(q[0], x));
    vqc.insert(VQG_RY(q[1], y));

    QCircuit circuit = vqc.feed();
    QProg prog;
    prog << circuit;

    std::cout << convert_qprog_to_originir(prog, machine) << std::endl << std::endl;

    auto gates = vqc.get_var_in_which_gate(x);

    int pos = shared_ptr<VariationalQuantumGate>(gates[0])->var_pos(x);

    vector<tuple<weak_ptr<VariationalQuantumGate>, size_t, double>> plus;
    plus.push_back(make_tuple(gates[0], pos, 3));

    QCircuit circuit2 = vqc.feed(plus);
    QProg prog2;
    prog2 << circuit2;

    std::cout << convert_qprog_to_originir(prog2,machine) << std::endl;

    return 0;
}

优化算法(梯度下降法)

本章节将讲解VQNet中优化算法的使用，包括经典梯度下降算法和改进后的梯度下降算法，它们都是在求解机器学习算法的模型参数，即无约束优化问题时，最常采用的方法之一。我们在 QPanda::Variational 中实现了这些算法，VanillaGradientDescentOptimizer 、 MomentumOptimizer 、 AdaGradOptimizer 、 RMSPropOptimizer 和 AdamOptimizer，它们都继承自 Optimizer 。

接口介绍

我们通过调用梯度下降优化器的 minimize 接口来生成一个优化器。常见的梯度下降优化器构造方式如下所示，

VanillaGradientDescentOptimizer::minimize(
    loss,   // 损失函数
    0.01,   // 学习率
    1.e-6); // 结束条件

MomentumOptimizer::minimize(
    loss,   // 损失函数
    0.01,   // 学习率
    0.9);   // 动量系数

AdaGradOptimizer::minimize(
    loss,   // 损失函数
    0.01,   // 学习率
    0.0,    // 累加量起始值
    1.e-10);// 很小的数值以避免零分母

RMSOptimizer::minimize(
    loss,   // 损失函数
    0.01,   // 学习率
    0.9,    // 历史或即将到来的梯度的贴现因子
    1.e-10);// 很小的数值以避免零分母

AdamOptimizer::minimize(
    loss,   // 损失函数
    0.01,   // 学习率
    0.9,    // 一阶动量衰减系数
    0.999,  // 二阶动量衰减系数
    1.e-10);// 很小的数值以避免零分母

实例

示例代码主要演示对离散点用直线进行拟合，我们定义训练数据X和Y，这两个变量表示离散点的坐标。定义两个可微分的变量w和b，其中w表示斜率b表示y轴截距。定义变量Y下划线表示斜率w乘上变量x加上截距。

接着我们定义损失函数loss。计算变量Y和变量Y下划线之间的均方值。

我们调用梯度下降优化器的 minimize 接口以损失函数，学习率和结束条件作为参数构造生成一个经典梯度下降优化器。

我们通过优化器的 get_variables 接口可以获得所有可微分的节点。

我们定义迭代次数为1000。然后调用优化器的 run 接口执行一次优化操作，其第二个参数表示当前的优化次数，目前只有 AdamOptimizer 这个优化器使用到了这个参数，其它优化器我们直接给0值即可。

我们可以通过优化器 get_loss 接口获得当前优化后的损失值。我们通过eval接口可以求得可微分变量的当前值。

#include "Variational/Optimizer.h"

int main()
{
    using namespace QPanda::Variational;

    MatrixXd train_x(17, 1);
    MatrixXd train_y(17, 1);

    train_x(0, 0) = 3.3;
    train_x(1, 0) = 4.4;
    train_x(2, 0) = 5.5;
    train_x(3, 0) = 6.71;
    train_x(4, 0) = 6.93;
    train_x(5, 0) = 4.168;
    train_x(6, 0) = 9.779;
    train_x(7, 0) = 6.182;
    train_x(8, 0) = 7.59;
    train_x(9, 0) = 2.167;
    train_x(10, 0) = 7.042;
    train_x(11, 0) = 10.791;
    train_x(12, 0) = 5.313;
    train_x(13, 0) = 7.997;
    train_x(14, 0) = 5.654;
    train_x(15, 0) = 9.27;
    train_x(16, 0) = 3.1;
    train_y(0, 0) = 1.7;
    train_y(1, 0) = 2.76;
    train_y(2, 0) = 2.09;
    train_y(3, 0) = 3.19;
    train_y(4, 0) = 1.694;
    train_y(5, 0) = 1.573;
    train_y(6, 0) = 3.366;
    train_y(7, 0) = 2.596;
    train_y(8, 0) = 2.53;
    train_y(9, 0) = 1.221;
    train_y(10, 0) = 2.827;
    train_y(11, 0) = 3.465;
    train_y(12, 0) = 1.65;
    train_y(13, 0) = 2.904;
    train_y(14, 0) = 2.42;
    train_y(15, 0) = 2.94;
    train_y(16, 0) = 1.3;

    var X(train_x);
    var Y(train_y);

    var W(1.0, true);
    var b(1.0, true);

    var Y_ = W * X + b;
    auto loss = sum(poly(Y - Y_, 2) / train_x.rows());
    auto optimizer = VanillaGradientDescentOptimizer::minimize(loss, 0.01, 1.e-6);

    auto leaves = optimizer->get_variables();
    for (size_t i = 0u; i < 1000; i++)
    {
        optimizer->run(leaves);
        std::cout << "i: " << i << "\t" << optimizer->get_loss()
            << "\t W:" << QPanda::Variational::eval(W, true)
            << "\t b:" << QPanda::Variational::eval(b, true)
            << std::endl;
    }

    return 0;
}

我们将散列点和拟合的直线进行绘图

综合示例

QAOA

QAOA 是众所周知的量子经典混合算法。 对于n对象的MAX-CUT问题，需要n个量子位来对结果进行编码，其中测量结果（二进制串）表示问题的切割配置。

我们通过 VQNet 可以有效地实现 MAX-CUT 问题的 QAOA 算法。 VQNet中QAOA的流程图如下所示。

我们给定一个MAX-CUT的问题如下

首先，我们输入 MAX-CUT 问题的图形信息，并构造相应的问题哈密顿量。

PauliOperator getHamiltonian()
{
    PauliOperator::PauliMap pauli_map{
        {"Z0 Z4", 0.73},{"Z2 Z5", 0.88},
        {"Z0 Z5", 0.33},{"Z2 Z6", 0.58},
        {"Z0 Z6", 0.50},{"Z3 Z5", 0.67},
        {"Z1 Z4", 0.69},{"Z3 Z6", 0.43},
        {"Z1 Z5", 0.36}
    };

    return PauliOperator(pauli_map);
}

然后，使用哈密顿量和待优化的变量参数x，构建 QAOA 的vqc。 QOP 的输入参数是问题哈密顿量、VQC 、一组量子比特和量子运行环境。QOP 的输出是问题哈密顿量的期望。 在这个问题中，损失函数是问题哈密顿量的期望，因此需要最小化 QOP 的输出。 我们通过使用梯度下降优化器 MomentumOptimizer 来优化vqc中的变量x。

#include "QPanda.h"
#include "Operator/PauliOperator.h"
#include "Variational/var.h"
#include "Variational/expression.h"
#include "Variational/utils.h"
#include "Variational/Optimizer.h"
#include <fstream>

using namespace std;
using namespace QPanda;
using namespace QPanda::Variational;

VQC parity_check_circuit(QVec &qubit_vec)
{
    VQC circuit;
    for (auto i = 0; i < qubit_vec.size() - 1; i++)
    {
        circuit.insert( VQG_CNOT(
            qubit_vec[i],
            qubit_vec[qubit_vec.size() - 1]));
    }

    return circuit;
}

VQC simulateZTerm(
    QVec &qubit_vec,
    var coef,
    var t)
{
    VQC circuit;
    if (0 == qubit_vec.size())
    {
        return circuit;
    }
    else if (1 == qubit_vec.size())
    {
        circuit.insert(VQG_RZ(qubit_vec[0], coef * t*-1));
    }
    else
    {
        circuit.insert(parity_check_circuit(qubit_vec));
        circuit.insert(VQG_RZ(qubit_vec[qubit_vec.size() - 1], coef * t*-1));
        circuit.insert(parity_check_circuit(qubit_vec));
    }

    return circuit;
}

VQC simulatePauliZHamiltonian(
    QVec& qubit_vec,
    const QPanda::QHamiltonian & hamiltonian,
    var t)
{
    VQC circuit;

    for (auto j = 0; j < hamiltonian.size(); j++)
    {
        QVec tmp_vec;
        auto item = hamiltonian[j];
        auto map = item.first;

        for (auto iter = map.begin(); iter != map.end(); iter++)
        {
            if ('Z' != iter->second)
            {
                QCERR("Bad pauliZ Hamiltonian");
                throw std::string("Bad pauliZ Hamiltonian.");
            }

            tmp_vec.push_back(qubit_vec[iter->first]);
        }

        if (!tmp_vec.empty())
        {
            circuit.insert(simulateZTerm(tmp_vec, item.second, t));
        }
    }

    return circuit;
}

int main()
{
    PauliOperator op = getHamiltonian();

    QuantumMachine *machine = initQuantumMachine();
    QVec qlist;
    for (int i = 0; i < op.getMaxIndex(); ++i)
        qlist.push_back(machine->qAlloc());

    VQC vqc;
    for_each(qlist.begin(), qlist.end(), [&vqc](Qubit* qbit)
    {
        vqc.insert(VQG_H(qbit));
    });

    int qaoa_step = 4;

    var x(MatrixXd::Random(2 * qaoa_step, 1), true);

    for (auto i = 0u; i < 2*qaoa_step; i+=2)
    {
        vqc.insert(simulatePauliZHamiltonian(qlist, op.toHamiltonian(), x[i + 1]));
        for (auto _q : qlist) {
            vqc.insert(VQG_RX(_q, x[i]));
        }
    }

    var loss = qop(vqc, op, machine, qlist);
    auto optimizer = MomentumOptimizer::minimize(loss, 0.02, 0.9);

    auto leaves = optimizer->get_variables();
    constexpr size_t iterations = 100;
    for (auto i = 0u; i < iterations; i++)
    {
        optimizer->run(leaves);
        std::cout << " iter: " << i << " loss : " << optimizer->get_loss() << std::endl;
    }

    QProg prog;
    QCircuit circuit = vqc.feed();
    prog << circuit;

    directlyRun(prog);
    auto result = quickMeasure(qlist, 100);

    for (auto i:result)
    {
        std::cout << i.first << " : " << i.second << " ";
    }

    return 0;
}

我们将测量的结果绘制出柱状图，可以看到’0001111’和’1110000’这两个比特串测量得到的概率最大，也正是我们这个问题的解。

基础概念回顾

---

基础定义

在物理学中，量子是物理量的最小的不可分的基本单位。比特是计算机术语，指信息量最小单位。 不同于经典比特，量子比特不再只能取值0或1，还可以处于0和1的任意比例叠加的中间态。

对量子比特进行的基本运算操作叫做量子门。

量子门分为单比特门和多比特门。 单比特门有Hadamard门、Pauli-X/Y/Z门和旋转X/Y/Z门等。二比特门既有受控的单比特门（例如CNOT门等）也有交换门。 通过受控等扩展方式，可以将单比特门和二比特门进一步扩展为多比特门。 注意，测量是一种特殊的量子门，它是不可逆的，会改变量子比特的状态。

任何量子算法，都是由这些基本的量子门组合得到的。

普适量子门的定义参见 常见量子逻辑门矩阵形式。

QPanda接口函数

在QPanda-2.0中，量子门的定义函数形式如下：

QGate H(Qubit *qubit);

Note

输入参数为量子比特Qubit及其他参数，返回值为可以插入量子线路的量子门QGate。

在QPanda-2.0中定义的量子门种类非常丰富。特别地，QPanda-2.0中支持完全自定义的量子门U4门，它的接口函数同时有以下几种重载：

QGate U4(double alpha, double beta, double gamma, double delta, Qubit *qubit);
QGate U4(Qubit *qubit, double alpha, double beta, double gamma, double delta);
QGate U4(QStat &matrix, Qubit *qubit);
QGate U4(Qubit *qubit, QStat &matrix);

如前文所述，量子门的接口函数有两种拓展操作：转置共轭和受控。两种操作都各有两种实现方式。

转置共轭操作的两种接口函数定义如下：

QGate gate = H(qubit);
QGate gate1 = gate.dagger();
gate.setDagger(true);

Note

dagger函数返回的是一个基于目标量子门的新量子门，setDagger返回的则是进行转置共轭后的目标量子门。

受控操作的两种接口函数定义如下：

QGate gate = H(qubit);
QGate gate1 = gate.control(QVec);
gate.setControl(QVec);

Note

区别与转置共轭操作类似，但受控函数入参是Qvec（qubit的vector）而非单个qubit。

实例

下面以一个程序实例，来展示基本的量子比特和量子门操作的代码实现。

#include "QPanda.h"
using namespace QPanda;

int main(void)
{
    auto qvm = initQuantumMachine(CPU);
    // 申请寄存器并初始化
    QVec q = qvm->qAllocMany(3);
    // 基于已有QVec定义
    QVec qubits = { q[0],q[1] };

    // 构建量子线路
    auto prog = createEmptyQProg();
    prog << H(q[0])
        << H(q[1])
        << H(q[0]).dagger()         // 转置共轭
        << X(q[2]).control(qubits); // 受控

    // 以概率方法输出结果量子态的理论值（并非测量）
    auto result = probRunDict(prog, q);
    destroyQuantumMachine(qvm);

    // 输出结果
    for (auto aiter : result)
    {
        cout << aiter.first << " : " << aiter.second << endl;
    }

    return 0;
}

输出结果应如下所示，分别以0.5的概率得到 \(\left|0\right\rangle\)和 \(\left|2\right\rangle\) ：

000:0.5
010:0.5

以上就是量子比特和量子门的基本定义和在QPanda-2.0中的调用介绍。

试验态制备与量子纠缠

---

试验态制备

试验态制备，指的是量子计算中任意算法的初始量子态的构造，是量子计算的初始步骤。

以单比特的两态空间为例，在实际量子运算中，我们可以直接得到的默认量子态是基态 \(\left|0\right\rangle\)，通过非门可以间接得到基态 \(\left|1\right\rangle\)。

对于任给的目标叠加量子态，我们则需要构造相应的量子门组合来得到。从基态 \(\left|0\right\rangle\) 出发制备任给目标叠加态的过程称为初态制备。

最大叠加态

以二比特态空间为例，从 \(\left|0\right\rangle^{\otimes2}\) 出发，对每个量子比特进行Hadamard门操作可以得到二比特空间中所有基态的均匀叠加。

类似地，在任意维态空间中，均可以借助Hadamard门从多维的 \(\left|0\right\rangle\) 基态出发，得到所有基态均匀线性组合的量子态。

这种量子态称为最大叠加态，很多量子计算中量子比特的初始状态要求为最大叠加态，量子计算的并行性也有赖于此。

通过试验态制备，我们就可以得到任意的基础量子态，从而完成量子计算中运算对象的构造。但是在执行运算操作之前，我们需要对量子计算所使用的量子比特给出明确的约束——纠缠关联。

在介绍量子纠缠之前，我们需要介绍一下纯态和混态。

非基态的量子态都为叠加态。叠加态又可以分为相干叠加和非相干叠加，分别称为纯态和混态。

纯态与混态的区分方式有多种，典型的有布洛赫球（Bloch Sphere），将态空间与Bloch球关联，球面上量子态为纯态，球体内的量子态为混态。

另一种重要的区分方式为密度矩阵，混态的密度矩阵非对角元均为0。

量子纠缠

如果一个量子系统的量子态 \(\left|\psi\right\rangle\) 可以表示成形如 \(\left|\psi\right\rangle=\left|\psi_0\ \right\rangle\otimes\left|\psi_1\right\rangle\) 的两个量子系统的直积形式，我们就将此量子态称为直积态。

Note

不能进行这种直积分解的量子态就是纠缠态。

例如对二比特的Bell态 \(\frac{1}{\sqrt2}\left|00\right\rangle+\frac{1}{\sqrt2}\left|11\right\rangle\)，它不能写成两个单比特量子态的直积形式。

量子纠缠态有超越经典关联的量子关联。为了发挥量子计算的并行性和高效性，量子计算使用的量子比特之间应当有着纠缠关联。

最大叠加态制备

下面是基于QPanda-2.0的最大叠加态制备的代码实现，调用的量子比特之间有着纠缠关联。

#include "QPanda.h"
USING_QPANDA

int main(void)
{
    auto qvm = initQuantumMachine(CPU);
    QVec qvec = qvm->qAllocMany(3);

    // 制备最大叠加态
    auto prog = createEmptyQProg();
    prog << applySingleGateToAll("H", qvec);

    // 以概率方法输出结果量子态的理论值（并非测量）
    auto result = probRunDict(prog, qvec);
    destroyQuantumMachine(qvm);

    // 输出结果
    for (auto aiter : result)
    {
        cout << aiter.first << " : " << aiter.second << endl;
    }

    return 0;
}

运行结果应当是以均匀概率1/8得到3比特空间中所有量子态：

000, 0.125
001, 0.125
010, 0.125
011, 0.125
100, 0.125
101, 0.125
110, 0.125
111, 0.125

Hadamard测试与SWAP测试

量子线路是一系列量子门操作的组合。众多量子线路中有一部分量子线路是在构造量子算法时会被反复使用，这些被高频调用的量子线路组件我们称之为量子算法基本线路，下面将介绍几种常用基本线路。

---

Hadamard Test

Hadamard Test量子线路的主要作用是对任给的幺正算符 \(U\) 和量子态 \(\psi\) ，可以给出该幺正算符在量子态上的投影期望 \(\left\langle\psi\left|U\right|\psi\right\rangle\) 。

Hadamard Test的量子线路图结构简单，如下所示。

整个量子线路可以视为对两个寄存器中量子比特组成的一个n+1维量子态 \(\left|0\right\rangle\left|\psi\right\rangle\) 进行量子门操作组合 \(Q=\left.(H\otimes I^{\otimes n})\left(C-U\right)(H\otimes I^{\otimes n}\right)\)，其中 \(C-U\) 表示基于幺正算符 \(U\) 的受控门。

输出结果及推广

对Hadamard Test量子线路的输出结果进行推导，有如下结论：

\[\begin{split}\begin{aligned} Q\left|0\right\rangle\left|\psi\right\rangle=\frac{\left|0\right\rangle+\left|1\right\rangle}{2} \ \left|\psi\right\rangle+\frac{\left|0\right\rangle-\left|1\right\rangle}{2}U\left|\psi\right\rangle \\ =\left|0\right\rangle\frac{\left|\psi\right\rangle+U\left|\psi\right\rangle}{2}+\left|1\right\rangle \ \frac{\left|\psi\right\rangle-U\left|\psi\right\rangle}{2}. \end{aligned}\end{split}\]

对输出的结果量子态进行测量得到 \(\left|0\right\rangle\)，\(\left|1\right\rangle\) 的概率为

\[\begin{aligned} P_0= \frac{1}{4}\left \| (I+U)(Q\left|{0} \right\rangle\left|\psi \right\rangle)| \right \|^2 \ =\frac{1+Re(\left\langle\psi\left|U\right|\psi\right\rangle)}{2}, \ P_1 = 1- P_0. \end{aligned}\]

由公式推导可知，Hadamard Test的结果相应的测量概率均与 \(Re(\left\langle\psi\left|U\right|\psi\right\rangle)\) 即幺正算符 \(U\) 在量子态 \(\psi\) 上投影期望的实部相关。

将图中测量之前的 \(H\) 门换成 \(RX(\frac{\pi}{2})\) 门，则可以得到概率与投影期望虚部相关的结果量子态。

代码实例

取 \(\left|\psi\right\rangle=\frac{\left|0\right\rangle+\left|1\right\rangle}{\sqrt2},U=H\)，Hadamard Test的一个代码实例如下：

#include "QPanda.h"
using namespace QPanda;

int main(void)
{
    auto qvm = initQuantumMachine(CPU);
    // 申请寄存器并初始化
    QVec cqv = qvm->qAllocMany(1);
    QVec tqv = qvm->qAllocMany(1);

    // 构建Hadamard量子线路
    auto prog = createEmptyQProg();
    prog << H(cqv[0]) << H(tqv[0])
        << H(tqv[0]).control(cqv[0])
        << H(cqv[0]);

    // 以概率方法输出结果量子态的理论值（并非测量）
    auto result = probRunDict(prog, cqv);
    destroyQuantumMachine(qvm);

    // 输出结果
    for (auto aiter : result)
    {
        cout << aiter.first << " : " << aiter.second << endl;
    }

    return 0;
}

输出结果应如下所示，分别以 \(\frac{1+\sqrt2/2}{2}\) 和 \(1-\frac{1+\sqrt2/2}{2}\) 的概率得到 \(\left|0\right\rangle\)和 \(\left|1\right\rangle\) ：

0:0.853553
1:0.146447

Hadamard Test有着多种形式和广泛用途，其中一种特殊形式是基本量子线路SWAP Test。

SWAP Test

任给两个维数相同的量子态，通过SWAP Test线路，可以得到两个量子态的保真度，反应了它们的重叠情况。

两个量子态 \(\left|\phi\right\rangle, \left|\psi\right\rangle\) 的保真度是指量子态内积范数的平方\(\left|\left\langle \phi |\psi\right\rangle \right|^2\)。

SWAP Test的量子线路图如下所示。

对SWAP Test的公式推导验证过程完全类似于Hadamard Test，结果量子态的第一个寄存器测量得到\(\left|0\right\rangle, \left|1\right\rangle\) 的概率均与给定的两个量子态的保真度相关。

\[\begin{aligned} P_0= \frac{1+\left|\left\langle\psi|\phi\right\rangle\right|^2}{2}, \ P_1 = 1- P_0. \end{aligned}\]

SWAP Test作为Hadamard的一种特殊形式，它对两个给定量子态给出了其保真度相关的测量结果，具有重要应用意义。在量子态的内积相关研究中有着重要作用。

如果将受控SWAP门替换为一般的受控门F那么可以还原得到一般形式的Hadamard Test的结果量子态

\[\begin{aligned} \frac{\left|0\right\rangle}{2}(I+F)\left|\phi\right\rangle \ \left|\psi\right\rangle+\frac{\left|1\right\rangle}{2}(I-F)\left|\phi\right\rangle\left|\psi\right\rangle. \end{aligned}\]

代码实例

SWAP Test的代码实例与Hadamard Test有细微区别。

取 \(\left|\phi\right\rangle=\frac{\left|0\right\rangle+\left|1\right\rangle} \ {\sqrt2},\left|\psi\right\rangle=\left|1\right\rangle\)，SWAP Test的一个代码实例如下：

#include "QPanda.h"
using namespace QPanda;

int main(void)
{
    auto qvm = initQuantumMachine(CPU);
    // 申请寄存器并初始化
    QVec cqv = qvm->qAllocMany(1);
    QVec tqv = qvm->qAllocMany(1);
    QVec qvec = qvm->qAllocMany(1);

    // 构建SWAP量子线路
    auto prog = createEmptyQProg();
    prog << H(cqv[0]) << H(tqv[0])
        << X(qvec[0])
        << SWAP(tqv[0], qvec[0]).control(cqv[0])
        << H(cqv[0]);

    // 以概率方法输出结果量子态的理论值（并非测量）
    auto result = probRunDict(prog, cqv);
    destroyQuantumMachine(qvm);

    // 输出结果
    for (auto aiter : result)
    {
        cout << aiter.first << " : " << aiter.second << endl;
    }

    return 0;
}

输出结果应如下所示，分别以 \(0.75\) 和 \(0.25\) 的概率得到 \(\left|0\right\rangle\)和 \(\left|1\right\rangle\) ：

0:0.75
1:0.25

振幅放大

振幅放大（Amplitude Amplification）线路的主要作用为对于给定纯态的振幅进行放大，从而调整其测量结果概率分布。

算法背景

对于某个已知大小的可二元分类且标准 \(f\) 确定的有限集合 \(\Omega\)，基于 \(f\) 可以将集合中的任一元素\(\left|\psi\right\rangle\) 表示为两个正交基态 \(\left|\psi_0\right\rangle,\left|\psi_1\right\rangle\) 的线性组合。

\[\begin{aligned} \left|\psi\right\rangle=sin\theta\left|\varphi_1\right\rangle+cos\theta\left|\varphi_0\right\rangle, \ \left|\varphi_0\right\rangle=\left|\varphi_1^\bot\right\rangle. \end{aligned}\]

振幅放大量子线路可以将叠加态 \(\left|\psi\right\rangle\) 的表达式中 \(\left|\psi_1\right\rangle\) 的振幅放大，从而得到一个结果量子态，能够以大概率测量得到目标量子态 \(\left|\psi_1\right\rangle\)。

假设我们可以构造出某种量子门操作的组合，记该组合为振幅放大算子 \(Q\) ，将 \(Q\) 作用 \(k\) 次于量子态\(\left|\psi\right\rangle\) 上得到形如下式的量子态

\[\begin{aligned} \left|\psi_k\right\rangle=\sin{k\theta}\left|\varphi_1\right\rangle+\cos{k\theta} \ \left|\varphi_0\right\rangle,\ k\theta\approx\frac{\pi}{2}. \end{aligned}\]

那么就完成了所需的振幅放大量子线路构建。

相应的量子线路图如下：

假设基于集合 \(\Omega\) 和分类标准 \(f\) 的量子态 \(\left|\psi\right\rangle\)已经完成制备，关键在于构造振幅放大算子 \(Q\) 。

定义振幅放大算子如下

\[\begin{aligned} P_1=I-2\left|\psi_1\right\rangle \left\langle\psi_1\right|, P=I-2\left|\psi\right\rangle \left\langle\psi\right|, Q=-PP_1. \end{aligned}\]

Note

如何通过集合 \(\Omega\) 和分类标准 \(f\) 来制备量子态？ \(P_1,P\) 又是怎样通过量子线路实现的？

简单验证可知在 \(\{\left|\varphi_1\right\rangle,\left|\varphi_0\right\rangle\}\)张成的空间中算子 \(Q\) 可以表示为

\[\begin{split}\begin{aligned} Q=\left[\begin{matrix}\cos{\left(2\theta\right)}&-\sin{\left(2\theta\right)}\\ \sin{\left(2\theta\right)}&\cos{\left(2\theta\right)}\\\end{matrix}\right] \end{aligned}\end{split}\]

实质上可以视为一个角度为 \(2\theta\) 的旋转量子门操作。因此有

\[\begin{aligned} Q^n\left|\psi\right\rangle=\sin{\left(2n+1\right)\theta}\left|\varphi_1 \right\rangle+\cos{\left(2n+1\right)\theta}\left|\varphi_0\right\rangle. \end{aligned}\]

选取合适的旋转次数 \(n\) 使得 \(\sin^2{\left(2n+1\right)\theta}\) 最接近 \(1\) 即可完成振幅放大量子线路。

相比经典的遍历分类方法，振幅放大量子线路可以充分体现量子计算的优势。

代码实例

取 \(\Omega=\{0,1\}, \left|\psi\right\rangle = \frac{\left|0\right\rangle+ \left|1\right\rangle}{2}, P_1=I-2\left|1\right\rangle \left\langle1\right|=Z\)，

振幅放大量子线路的相应代码实例如下

#include "QPanda.h"
using namespace QPanda;

int main(void)
{
   auto qvm = initQuantumMachine(CPU);
   // 申请寄存器并初始化
   QVec qvec = qvm->qAllocMany(1);

   // 构建振幅放大量子线路
   auto prog = createEmptyQProg();
   prog << H(qvec[0]);
   for (int i = 0; i < 7; i++)
   {
     prog << RY(qvec[0], PI / 2);
   }

   // 以概率方法输出结果量子态的理论值（并非测量）
   auto result = probRunDict(prog, qvec);
   destroyQuantumMachine(qvm);

   // 输出结果
   for (auto aiter : result)
   {
      cout << aiter.first << " : " << aiter.second << endl;
   }

   return 0;
}

输出结果应如下所示，分别以 \(1\) 和 \(0\) 的概率得到 \(\left|0\right\rangle\)和 \(\left|1\right\rangle\) ：

0:1
1:0

量子傅里叶变换

量子傅里叶变换（QFT）实质上是经典的逆离散傅里叶变换（IDFT）的量子版本。

量子傅里叶变换可以将存在于基向量中的数据与振幅中的数据在一定条件下相互转换。

基本定义

如图所示，QFT可以简单地通过对IDFT进行替换得到，QFT和DFT本质上都是同一个向量在两个等价空间中的不同表示形式，即基向量的更换。

\[\begin{split}\begin{aligned} y_k\rightarrow\frac{1}{\sqrt N}\mathrm{\Sigma}_{j=0}^{N-1}x_j \ e^{\frac{2\pi\ i}{N}jk},\\ \left|x\right\rangle\rightarrow \ \frac{1}{2^\frac{n}{2}}\Sigma_{k=0}^{2^n-1}e^{\frac{2\pi i}{2^n} \ xk}\left|k\right\rangle. \end{aligned}\end{split}\]

由定义可知，空间 \(span\{\left|x\right\rangle\}\) 中的某个向量 \(\mathrm{\Sigma}_x\alpha_x\left|x\right\rangle\) 通过傅里叶变换可以表示为另一个等价空间 \(span\{\left|k\right\rangle\}\) 中基向量的线性组合\(\mathrm{\Sigma}_k\beta_k\left|k\right\rangle\), 且线性组合的系数 \(\beta_k\) 由\(\left|x\right\rangle\) 和 \(\alpha_x\) 决定。

Note

量子傅里叶变换/逆变换，实质上可以视为一种振幅和基向量的相互转化。

量子线路构造

对QFT的量子线路实现需要对其表达式进行变形，得到可以用现有普适量子门组合实现的变换过程。

QFT的求和形式与张量积形式

对任给整数 \(x\) ，由二进制展开 \(k=\mathrm{\Sigma}_{i=1}^nk_i2^{n-i}\)，对\(\left|x\right\rangle\) 进行量子傅里叶变换的结果可表示为

\[\begin{split}\begin{aligned} & QFT(\left|x\right\rangle)=\frac{1}{2^\frac{n}{2}}\mathrm{\Sigma}_{k=0}^{2^n-1}e^\frac{2\pi ixk}{2^n} \ \left|k\right\rangle=\frac{1}{2^\frac{n}{2}}\mathrm{\Sigma}_{k_1=0}^1\cdots\mathrm{\Sigma}_{k_n=0}^1 \ e^{2\pi ixk\left(\mathrm{\Sigma}_{l=1}^nk_l2^{-l}\right)}\left|k_1\cdots k_n\right\rangle \\ & =\frac{1}{2^\frac{n}{2}}\mathrm{\Sigma}_{k_1=0}^1\cdots\mathrm{\Sigma}_{k_n=0}^1\otimes_{l=1}^n e^{2\pi ix k_l2^{-l}} \left|k_l\right\rangle=\frac{1}{2^\frac{n}{2}}\otimes_{l=1}^n(\left|0\right\rangle+e^{2\pi ix2^{-l}} \ \left|1\right\rangle). \end{aligned}\end{split}\]

由上式可知，QFT可以将特定量子态 \(\left|x\right\rangle\) 表示为另一组基的线性组合，而这个线性组合还能表示为多个单比特量子态\(\frac{1}{\sqrt{2}}(\left|0\right\rangle + e^{2\pi ix2^{-l}}\left|1\right\rangle)\) 的张量积。

因此对任给整数 \(x\)，如果可以由二进制展开位 \(\left|x_{n+1-l}\right\rangle\) 快速构造量子态 \(\frac{1}{\sqrt{2}}(\left|0\right\rangle + e^{2\pi ix2^{-l}}\left|1\right\rangle)\)，那么就可以通过张量积形式的QFT表达式完成相应QFT量子线路的构造。

二进制展开与量子态制备

任给整数 \(x\) 进行二进制展开近似：

\[\begin{aligned} x/2^m \approx \left[x_1\cdots x_m\right]/2^m=\left[0.x_1\cdots x_m\right]=\Sigma_{k=1}^mx_k2^{-k}, \end{aligned}\]

而

\[\begin{aligned} 2\pi ix2^{-l}=2\pi i\left[x_1\cdots x_n\right]2^{-l}=2\pi i\left[0.x_{n-l}\cdots x_n\right]. \end{aligned}\]

于是制备 \(\frac{1}{\sqrt{2}}(\left|0\right\rangle + e^{2\pi ix2^{-l}}\left|1\right\rangle)\) 转化为制备 \(\frac{1}{\sqrt{2}}(\left|0\right\rangle + e^{2\pi i [0.x_{n-l}\cdots x_n]}\left|1\right\rangle)\) 。

注意到 \(H\left|0\right\rangle = \frac{1}{\sqrt{2}}(\left|0\right\rangle + \left|1\right\rangle) = \ \frac{1}{\sqrt{2}}(\left|0\right\rangle + e^{2\pi i [0.x_n]}\left|1\right\rangle)\) ，而

\[\begin{split}\begin{aligned} & \frac{1}{\sqrt{2}}(\left|0\right\rangle + e^{2\pi i [0.x_{n-1} x_n]}\left|1\right\rangle) = \ \frac{1}{\sqrt{2}}(\left|0\right\rangle + e^{2\pi i [0.x_{n-1}]} e^{2\pi i [0.0 x_n]} \left|1\right\rangle),\\ & R_m \left|0\right\rangle = \left|0\right\rangle, R_m \left|1\right\rangle = e^{2\pi i \frac{1}{2^m}}\left|1\right\rangle. \end{aligned}\end{split}\]

定义受控旋转量子门 \((C-R)_{j-k+1}\) 满足

\[\begin{aligned} (C-R)_{j-k+1} \frac{1}{\sqrt{2}}(\left|0\right\rangle + e^{2\pi i [0.x_{n-j}]} \left|1\right\rangle)\left|x_{n-k}\right\rangle = \frac{1}{\sqrt{2}}( \left|0\right\rangle + e^{2\pi i [0.x_{n-j}0\cdots 0x_{n-k}]}\left|1\right\rangle. \end{aligned}\]

于是利用量子门 \(H\) 和 \((C-R)_{j-k+1}\) 就可以完成对量子态\(\frac{1}{\sqrt{2}}(\left|0\right\rangle + e^{2\pi ix2^{-l}}\left|1\right\rangle)\)的制备，进而完成QFT的量子线路。

QFT的量子线路图如下所示

特别地，注意到上图中初始量子态为 \(\left|x_i\right\rangle\) 的量子比特对应的结果量子态为\(\frac{1}{\sqrt{2}}(\left|0\right\rangle + e^{2\pi ix2^{n+1-l}}\left|1\right\rangle)\)而非 \(\frac{1}{\sqrt{2}}(\left|0\right\rangle + e^{2\pi ix2^{-l}}\left|1\right\rangle)\) ，因此实际使用时还需要追加相应的多组 \(SWAP\) 门。

代码实现

QFT在一维情况就是Hadamard量子门。 基于QPanda-2.0的QFT接口函数如下：

QCircuit QFT(QVec qvec);

选取 \(\left|x\right\rangle=\left|000\right\rangle\) 验证QFT的代码实例如下

#include "QPanda.h"
using namespace QPanda;

int main(void)
{
   auto qvm = initQuantumMachine(CPU);
   // 申请寄存器并初始化
   QVec qvec = qvm->qAllocMany(3);

   // 调用QFT函数
   auto prog = createEmptyQProg();
   prog << QFT(qvec);

   // 以概率方法输出结果量子态的理论值（并非测量）
   directlyRun(prog);
   auto result = probRunTupleList(prog, qvec);
   destroyQuantumMachine(qvm);

   // 输出结果
   for (auto aiter : result)
   {
      cout << aiter.first << " : " << aiter.second << endl;
   }

   return 0;
}

由前文中QFT的定义及 \(\left|x\right\rangle=\left|000\right\rangle\) 可知输出结果应当以均匀概率 \(\frac{1}{8}\) 得到所有量子态，即

000, 0.125
001, 0.125
010, 0.125
011, 0.125
100, 0.125
101, 0.125
110, 0.125
111, 0.125

量子相位估计

量子相位估计（QPE）可以计算给定幺正算符U的特征值的相位，即求解 \(U\left|\psi\right\rangle= \ e^{2\pi i\varphi}\left|\psi\right\rangle\) 中的 \(\varphi\)，此处 \(\left|\psi\right\rangle\) 为U的特征向量。

经典形式的QPE是在QFT的基础上构造的。

量子线路结构概览

假设已经构造好特征向量 \(\left|\psi\right\rangle\)，量子相位估计包含如下步骤：

1. 通过一系列特殊旋转量子门操作将U的特征值相位分解转移到辅助量子比特的振幅上；

2. 对辅助量子比特执行IQFT，将振幅上的特征值相位转移到基向量上；

3. 对辅助量子比特的基向量分别进行测量后综合可得到特征值的相位信息。

对于幺正算符 \(U\) 的一个特征量子态 \(\left|\psi\right\rangle\)，可以通过特定的量子门组合将该量子态对应的特征值相位提取到振幅，但量子态的振幅难以有效准确地测量。

必须借助其他量子门组合将特征值相位数据进行整合，最终通过IQFT可以由振幅到基向量进行数据转化的功能将特征值转移到基向量中。

Note

量子相位估计本质上是为了提取幺正算符的特征值相位，并以便于测量的形式输出。

量子线路构建

特征量子态与特征值相位提取

由特征量子态的定义有 \(U\left|\psi\right\rangle = e^{2\pi i\varphi}\left|\psi\right\rangle\)，

于是由幺正算符 \(U\) 可以定义受控量子门 \((C-U)\) 使得

\[\begin{aligned} (C-U^{2^t})(a\left|0\right\rangle+b\left|1\right\rangle)\otimes\left|\psi\right\rangle \ =(a\left|0\right\rangle+e^{2\pi i\varphi2^t}b\left|1\right\rangle)\otimes\left|\psi\right\rangle. \end{aligned}\]

特征值相位 \(\varphi\) 通过这种受控变换可以提取到振幅中。

特征值相位由振幅转移到基向量

选取一组初始化为最大叠加态的辅助比特，通过受控量子门可以将特征值相位提取到振幅中：

\[(C-U^{2^0})\cdots(C-U^{2^n})\frac{1}{2^\frac{n}{2}}\otimes_{t=1}^n (\left|0\right\rangle+\left|1\right\rangle)= (\left|0\right\rangle+e^{2\pi i\varphi2^{1-1}}\ \left|1\right\rangle)\cdots(\left|0\right\rangle+e^{2\pi i\varphi2^{n-1}}\left|1\right\rangle).\]

此时辅助比特中的量子态形式与QFT的结果量子态相近，借助IQFT有如下结果：

\[\begin{split}\begin{aligned} & QFT^{-1}\frac{1}{2^\frac{n}{2}}\otimes_{t=1}^n(\left|0\right\rangle+e^{2\pi i\varphi2^{t-1}} \left|1\right\rangle) \\ & =QFT^{-1}\frac{1}{2^\frac{n}{2}}\mathrm{\Sigma}_{k=0}^{2^n-1}e^{2\pi i \varphi k}\left|k\right\rangle \\ & =\frac{1}{2^n}\mathrm{\Sigma}_{k=0}^{2^n-1}\mathrm{\Sigma}_{x=0} ^{2^n-1}e^{-\frac{2\pi ik}{2^n}\left(x-2^n\varphi\right)}\left|x\right\rangle. \end{aligned}\end{split}\]

含特征值相位的基向量测量

对得到的结果量子态进行测量，结果可以分为两类：

1. 如果存在正整数 \(2^n\varphi\in \mathbb{Z}\)，则可以以概率 \(1\) 测量得到 \(\left|x\right\rangle=\left|2^n\varphi\right\rangle\)

2. 否则以至少概率 \(\frac{4}{\pi^2}\) 得到最接近 \(2^n\varphi\) 的整数，进而得到近似解

Note

如何从最接近 \(2^n\varphi\) 的整数反推得到 \(\varphi\) ？（提示：连续分数展开）

测量结果得到的是相位 \(\varphi\) 的近似解，近似解的精度与辅助比特的数目 \(n\) 相关。\(2^n\varphi\in \mathbb{Z}\) 的情况代表辅助比特的数目已经大于 \(\varphi\) 的二进制展开小数位数，因此才能得到精确解。

量子线路图与代码实现

QPE的量子线路图如下所示

由上文中的定义，我们可以基于QPanda-2.0直接给出QPE的函数实现。

量子线路总共可以分为三个部分，特征量子态制备与辅助比特量子态初始化、特征值相位提取、逆量子傅里叶变换。程序实现的核心内容如下：

#include "QPanda.h"
using namespace QPanda;

QCircuit QPE(vector<Qubit*> controlqvec, vector<Qubit *> targetqvec, QGEN qc)
{
   QCircuit  circuit = CreateEmptyCircuit();
   for (auto i = 0; i < controlqvec.size(); i++)
   {
      circuit << H(controlqvec[i]);
   }

   for (auto i=0;i<controlqvec.size();i++)
   {
      circuit << controlUnitaryPower(targetqvec, controlqvec[controlqvec.size() - 1 - i], i, qc);
   }
   circuit << QFT (controlqvec).dagger();
   return circuit;
}

选取 \(U=RY(\frac{\pi}{4}),\left|\psi\right\rangle=\left|0\right\rangle+i\left|1\right\rangle\) ， 对应的特征值为 \(e^{-i\frac{\pi}{8}}\) ，验证QPE的代码实例如下

#include "QPanda.h"
using namespace QPanda;

int main(void)
{
   auto qvm = initQuantumMachine(CPU);
   // 申请寄存器并初始化
   QVec qvec = qvm->qAllocMany(1);
   QVec cqv = qvm->qAllocMany(2);

   // 提取特征值相位并合并到基向量
   auto prog = createEmptyQProg();
   prog << H(cqv[0]) << H(cqv[1]);
   prog << S(qvec[0]);
   prog << RY(qvec[0], PI / 4).control(cqv[1]);
   prog << RY(qvec[0], PI / 4).control(cqv[0]);
   prog << RY(qvec[0], PI / 4).control(cqv[0]);
   prog << QFT(cqv).dagger();

   // 以概率方法输出结果量子态的理论值（并非测量）
   auto result = probRunDict(prog, cqv);
   destroyQuantumMachine(qvm);

   // 输出结果
   for (auto aiter : result)
   {
      cout << aiter.first << " : " << aiter.second << endl;
   }

   return 0;
}

由前文可知输出结果应当以较大概率得到量子态 \(\left|0\right\rangle\)

000, 0.821067
001, 0.0732233
010, 0.0324864
011, 0.0732233

量子四则运算

在特定情况下，量子计算机中需要实现基本的四则运算。量子加法器及衍生出来的量子四则运算可以满足这些计算需求。

加法器算法背景

除了测量之外的所有量子门操作都是酉变换，因而不含测量的量子线路整体是可逆的。

量子加法器的量子线路也应当可逆，因而输入输出是数量相等的量子比特，量子线路图如下所示。

图中包含了两种子量子线路模块MAJ和UMA，作用分别是获得当前二进制位的进位数值和当前二进制位的结果数值。

MAJ量子线路组件

MAJ的量子线路如下所示。

下面对MAJ量子线路的具体功能进行解读。

MAJ量子线路的输入分别为前一位的进位值 \(c_i\)、当前位的两个待加值 \(a_i,b_i\)，输出为\(a_i+c_i \ \text{mod}\ 2\)， \(a_i+b_i \ \text{mod} \ 2\) 和当前位进位值 \(c_{i+1}\) 。

MAJ模块是为了实现获得进位，我们想要得到进位 \(c_{i+1}\) ,也就是要从 \(a_i+b_i+c_i\) 出发，判断 \((a_i+b_i+c_i)/2\)。

在待加值中任选一个数 :math:`a_i`对进位情况进行如下枚举，

1. \(a_i=0\)， \(c_i=[(a_i+b_i)\%2]*[(a_i+c_i)\%2]\)；

2. \(a_i=1\)， \(c_i=([(a_i+b_i)\%2]*[(a_i+c_i)\%2]+1)\%2\)；

因此，只需要考察 \(a_i,[(a_i+b_i)\%2]*[(a_i+c_i)\%2]\) 就可以判断进位情况。

从现有的量子逻辑门出发，制备量子态 \(a_i, (a_i+b_i)\%2, (a_i+c_i)\%2\)，即可以准确判断出进位的情况。此处选取的考察对象并不唯一，其他方案会衍生出相应的量子线路。

制备三个量子态的方案如上图中所示，使用CNOT门来完成模2加法得到 \((a_i+b_i)\%2, (a_i+c_i)\%2\)，使用Toffoli门完成\(a\) 与 \([[(a_i+b_i)\%2]*[(a_i+c_i)\%2]\) 的异或运算。

UMA量子线路组件

UMA的量子线路如下所示。

下面对UMA量子线路的具体功能进行解读。

UMA量子线路的输入分别为 \(a_i+c_i \ \text{mod}\ 2\)， \(a_i+b_i \ \text{mod} \ 2\) 和当前位进位值 \(c_{i+1}\)，输出为 \(c_i\)， \(a_i+b_i+c_i \ \text{mod} \ 2 := s_i\) 和 \(a_i\)。

UMA模块是为了实现获得当前位结果，我们想要得到当前位 \(s_i\) ,也就是要得到 \((a_i+b_i+c_i)\%2\)。

参考MAJ模块，首先通过与MAJ所用的完全相反的TOffoli门由 \(c_{i+1}\) 得到 \(a_i\)，然后利用与MAJ所用的相反的CNOT变换得到 \(c_i\) ，综合已有的 \(a_i+b_i \ \text{mod} \ 2\) ，于是可以通过简单的CNOT门得到 \((a_i+b_i+c_i)\%2\)。

整个过程的前两步都可以视为MAJ相应量子门的逆变换。

Note

MAJ的实现量子线路是不唯一的，那么UMA也是不唯一的吗？

量子四则运算

量子加法器

量子加法器的原理如前文所示。

量子减法器

基础的加法器只支持非负整数的加法。对于小数要求输入的被加数a和b必须小数点位置相同，小数点对齐后整体长度相同。

对于带符号变换的量子加法，则需要追加辅助比特用于记录符号位。任给两个目标量子态 \(A,B\)，对第二个量子态 \(B\) 进行特定的补码操作，然后转换为\(A-B=A+(-B)\)，此处的 \(-B\) 并不以符号位取反的方式实现。

该特定的补码操作为：符号位为正则不变，符号位为负需要按位取反后再加1。因此需要一个额外的辅助比特来控制是否进行求补码的操作。

量子减法器实质上就是量子加法器的带符号版本。

量子乘法器

量子乘法器是基于加法器完成的。选择乘数 \(A\) 作为受控比特，选择乘数 \(B\) 以二进制展开逐位作为控制比特，将受控加法器的运算结果累加到辅助比特中。每完成一次 \(B\) 控制的受控加法就将乘数 \(A\) 左移一位并在末位补零。

于是把通过受控加法输出的数值在辅助比特中累加起来，得到乘法结果。

量子除法器

量子除法器是基于量子减法器完成的，通过执行减法后被除数的符号位是否改变来完成大小比较，并决定除法是否终止。

除数减去被除数时，商结果加1。每完成一次减法后，重新进行被除数与除数的大小比较，直至除尽或者达到预设精度。

因此还需要额外追加一个存储精度参数的辅助比特。

代码实现及使用说明

量子加法器

在QPanda-2.0中加法器的接口函数如下：

QCircuit QAdder(
   QVec &adder1,
   QVec &adder2,
   Qubit* c,
   Qubit* is_carry);

QCircuit QAdder(
   QVec &adder1,
   QVec &adder2,
   Qubit* c);

QCircuit QAdd(
   QVec& a,
   QVec& b,
   QVec& k);

前两种接口函数的区别是是否保留进位is_carry，但都只支持正数加法。参数中adder1与adder2为执行加法的比特且格式完全一致，c为辅助比特。

第三种加法器接口函数是带符号的加法器，是基于量子减法器实现的。待加数添加了符号位，相应的辅助比特也从1-2个单比特变为一个adder1.size()+2比特。

加法的输出比特都是adder1，其他非进位比特不变。

量子减法器

量子减法器基于基本加法器完成，同时也是带符号的加法器的基础。

在QPanda-2.0中减法器（带符号的加法器）的接口函数如下：

QCircuit QSub(
   QVec& a,
   QVec& b,
   QVec& k);

与带符号的加法器相同，两个待减数的量子比特最高位为符号位，辅助比特k.size()=a.size()+2。

减法的输出比特是a，其他比特不变。

量子乘法器

在QPanda-2.0中乘法器的接口函数如下：

QCircuit QMultiplier(
   QVec& a,
   QVec& b,
   QVec& k,
   QVec& d);

QCircuit QMul(
   QVec& a,
   QVec& b,
   QVec& k,
   QVec& d);

两个接口函数的输入待乘量子比特都包含符号位，但只有QMul支持带符号的乘法运算。

相应的，QMultiplier中，辅助比特k.size()=a.size()+1，结果比特d.size()=2*a.size()。

QMul中，辅助比特k.size()=a.size()，结果比特d.size()=2*a.size()-1。

乘法的输出比特都是d，其他比特不变。

如果等长的输入比特a和b存在小数点，那么在输出比特d中的小数点位置坐标为输入比特中的2倍。

量子除法器

在QPanda-2.0中除法法器的接口函数如下：

QProg QDivider(
   QVec& a,
   QVec& b,
   QVec& c,
   QVec& k,
   ClassicalCondition& t);

QProg QDivider(QVec& a,
   QVec& b,
   QVec& c,
   QVec& k,
   QVec& f,
   std::vector<ClassicalCondition>& s);

QProg QDiv(
   QVec& a,
   QVec& b,
   QVec& c,
   QVec& k,
   ClassicalCondition& t);

QProg QDiv(
   QVec& a,
   QVec& b,
   QVec& c,
   QVec& k,
   QVec& f,
   std::vector<ClassicalCondition>& s);

与乘法器类似，除法器也是分为两类，尽管输入的待运算比特都带有符号位，但接口分为带符号运算和仅限正数两类。

k为辅助比特，t或s为限制QWhile循环次数的经典比特或。

此外，除法器有除不尽的问题，因此可以接口函数有如上四种，对应的输入和输出参数分别有如下性质：

1. QDivider返还余数和商（分别存储在a和c中）时，c.size()=a.size()，但k.size()=a*size()*2+2;

2. QDivider返还精度和商（分别存储在f和c中）时，c.size()=a.size()，但k.size()=3*size()*2+5；

3. QDiv返还余数和商（分别存储在a和c中）时，c.size()=a.size()，但k.size()=a*size()*2+4;

4. QDivider返还精度和商（分别存储在f和c中）时，c.size()=a.size()，但k.size()=a*size()*3+7；

此外，如果参数不能满足量子四则运算所需的比特数目，那么计算依然会进行但结果会溢出。

除法的输出比特是c，带精度的除法中a,b,k都不会变，否则b,k不变但a中存储余数。

示例

下面是一个简单的基于QPanda-2.0调用量子四则运算的代码示例

#include "QPanda.h"
using namespace QPanda;

int main(void)
{
   auto qvm = initQuantumMachine();

   // 为了节约比特数，辅助比特有大量互相借用
   QVec qdivvec = qvm->qAllocMany(10);
   QVec qmulvec = { qdivvec[0],qdivvec[1],qdivvec[2],qdivvec[3],
      qdivvec[4],qdivvec[5],qdivvec[9] };
   QVec qsubvec = { qmulvec[0],qmulvec[1],qmulvec[2],qmulvec[3],
      qmulvec[4],qmulvec[5] };
   QVec qvec1 = qvm->qAllocMany(4);
   QVec qvec2 = qvm->qAllocMany(4);
   QVec qvec3 = qvm->qAllocMany(4);
   auto cbit = qvm->cAlloc();
   auto qcProg = CreateEmptyQProg();

   // 4/1=4
   qcProg << bind_data(4, qvec3);
   qcProg << bind_data(1, qvec2);
   qcProg << QDivider(qvec3, qvec2, qvec1, qdivvec, cbit);
   qcProg << bind_data(1, qvec2);

   // 4+1=5
   qcProg << bind_data(1, qvec2);
   qcProg << QAdd(qvec1, qvec2, qsubvec);
   qcProg << bind_data(1, qvec2);

   // 5-3=2
   qcProg << bind_data(3, qvec2);
   qcProg << QSub(qvec1, qvec2, qsubvec);
   qcProg << bind_data(3, qvec2);

   // 2*5=10
   qcProg << bind_data(5, qvec2);
   qcProg << QMul(qvec1, qvec2, qvec3, qmulvec);
   qcProg << bind_data(5, qvec2);

   auto result = probRunDict(qcProg, qmulvec);
   destroyQuantumMachine(qvm);

   for (auto aiter : result)
   {
      cout << aiter.first << " : " << aiter.second << endl;
   }

   return 0;
}

执行的计算为 \((4/1+1-3)*5=10\)，因此结果应当以概率 \(1\) 得到 \(\left|10\right\rangle\)即 \(\left|1010\right\rangle\)。

10:1

HHL算法

HHL算法是一种求解线性方程组的量子算法，线性方程组在许多领域中都有着广泛的实际应用。

问题背景概述

线性方程组问题可定义为： 给定矩阵 \(A\in C^{N\times N}\) 和向量 \(\vec{b}\in C^N\) ，找到 \(\vec{x}\in C^N\) 满足 \(A\vec{x}=\vec{b}\)。

如果矩阵A每行或每列最多具有s个非零元，则将线性方程组称为s-稀疏线性方程组。用经典算法（共轭梯度法）来解决N维的s-稀疏线性方程组，需要的时间复杂度为 \(O\left(Nsk\log{\left(\frac{1}{\varepsilon}\right)}\right)\)，这里k表示系统的条件数， \(\varepsilon\) 表示近似的精度。HHL是一种量子算法，当A是自共轭矩阵时，用HHL算法解线性方程组的时间复杂度为 \(O\left(\log{\left(N\right)}s^2\frac{k^2}{\varepsilon}\right)\)。

HHL算法相对于经典算法有着指数级的加速，但经典算法可以返回精确解，而HHL算法只能返回近似解。

Note

HHL算法是一种纯量子算法，它和它的改进版的出现对于证明量子算法的实用性有着重大意义。

算法原理

在对线性方程组进行一定格式转换后可以以HHL算法进行求解，HHL算法主要包含了以下三大步骤，并需要使用右端项比特、存储比特和辅助比特总共三个寄存器。

1. 构造右端项量子态，对存储比特及右端项比特进行参数含左端项矩阵的相位估计，将左端项矩阵的整数形式特征值全部转移到存储比特的基向量中。

2. 进行一系列参数含特征值的受控旋转，过滤出所有的特征值相关量子态，将特征值从存储比特的基向量转移到振幅；

3. 对特征存储比特及右端项比特进行逆相位估计，将存储比特振幅上的特征值合并到右端项比特上，当辅助比特测量得到特定状态时，在右端项比特上可得到解的量子态。

在进行算法具体步骤之前，需要对经典形式的线性方程组求解问题 \(A\vec{x}=\vec{b}\) 进行特定转换：

不失一般性地假设矩阵 \(A\) 为自共轭矩阵，否则取

\[\begin{split}\begin{aligned} C_A=\left[\begin{matrix}0&A\\A^H&0\\\end{matrix}\right], C_b=\left[\begin{matrix}b\\0\\\end{matrix}\right], C_x=\left[\begin{matrix}0\\x\\\end{matrix}\right], \end{aligned}\end{split}\]

使得 \(C_A\vec{C_x}=\vec{C_b}\) 成立且满足 \(C_A\) 自共轭。

以下内容中将默认A为自共轭矩阵。

将向量 \(\vec{b},\vec{x}\) 分别归一化后采用编码到振幅上的方式映射到量子态 \(\left|b\right\rangle,\left|x\right\rangle\) ，原问题转换为 \(A\left|x\right\rangle=\left|b\right\rangle\).

对矩阵 \(A\) 进行谱分解有

\[\begin{aligned} A=\sum_{j=0}^{N-1}\lambda_j\left|u_j\right\rangle\left\langle u_j\right|,\lambda_j\in R. \end{aligned}\]

其中 \({{\lambda}_j,u_j}\) 为矩阵A的特征对（特征值及相应的特征向量）。

将 \(\left|b\right\rangle\) 以特征向量基展开，得到

\[\begin{aligned} \left|b\right\rangle=\sum_{j=0}^{N-1}{b_j\left|u_j\right\rangle},b_j\in C. \end{aligned}\]

于是原方程组的解可表示为

\[\left|x\right\rangle=A^{-1}\left|b\right\rangle=\sum_{j=0}^{N-1}{\lambda_j^{-1}b_j\left|u_j\right\rangle.}\]

显而易见算法的基本思路应当是从右端项量子态 \(\left|b\right\rangle\) 出发构造解量子态 \(\left|x\right\rangle\) 。

通过QPE提取特征值

为了将矩阵 \(A\) 的特征值提取到解量子态的振幅，首先需要完成特征值的提取。 由前文可知，QPE量子线路可以用于特征值提取。

对 \(\left|0\right\rangle^{\otimes n}\left|b\right\rangle\) 进行一次QPE操作，得到

\[\begin{aligned} {QPE(\left|0\right\rangle}^{\otimes n}\left|b\right\rangle)=\sum_{j=0}^{N-1}{b_j\left|\widetilde{\lambda_j}\right\rangle\left|u_j\right\rangle}. \end{aligned}\]

其中 \(\widetilde{\lambda_j}\) 是对应特征值 \(\lambda_j\) 的近似整数，细节参见QPE部分介绍。 于是矩阵A的特征值信息存入到了基向量 \(\left|\widetilde{\lambda_j}\right\rangle\) 中。

通过受控旋转转移特征值

构造如下受控旋转 \(CR(k)\)

\[\begin{split}\begin{aligned} CR(k)(\left|a\right\rangle\left|j\right\rangle)=\left\{\begin{matrix} RY(\arccos{\frac{C}{k}})\left|a\right\rangle\left|k\right\rangle,j=k,\\ \left|a\right\rangle\left|j\right\rangle,j\neq k, \end{matrix}\right. \end{aligned}\end{split}\]

式中 \(C\) 为 \(\widetilde{\lambda_j}\) 的归一化系数，有 \(C\le\smash{\displaystyle\min_{j}} {\left|\widetilde{\lambda_j}\right|}\)从而任意 \(\frac{C^2}{{\widetilde{\lambda_j}}^2}\le 1\)。对 \(\sum_{j=0}^{N-1}{b_j\left|0\right\rangle \left|\widetilde{\lambda_j}\right\rangle\left|u_j\right\rangle}\) 经过遍历式旋转量子门操作后可以得到

\[\begin{aligned} (\prod (CR(k)\otimes I))\sum_{N-1}^{j=0}b_j\left|0\right\rangle\left|\widetilde{\lambda_j}\right\rangle \left|u_j\right\rangle=\sum_{j=0}^{N-1}{(\sqrt{1-\frac{C^2}{{\widetilde{\lambda_j}}^2}}\left|0\right\rangle +\frac{C}{\widetilde{\lambda_j}}\left|1\right\rangle)b_j\left|\widetilde{\lambda_j}\right\rangle\left|u_j\right\rangle}. \end{aligned}\]

通过逆QPE输出结果量子态

理论上，受控旋转后的量子态已经可以通过测量得到解量子态 \(\left|x\right\rangle\) 。

但为了避免出现 \(\left|u_j\right\rangle\) 相同但\(\left|\widetilde{\lambda_j}\right\rangle\) 不同的需要合并的量子态\(\frac{C }{\widetilde{\lambda_j}}b_j\left|1\right\rangle\left|\widetilde{\lambda_j}\right\rangle\left|u_j\right\rangle\)，应当选择逆QPE操作来得到形如 \(\frac{C }{\widetilde{\lambda_j}}b_j\left|1\right\rangle\left|0\right\rangle\left|u_j\right\rangle\) 的结果量子态。

对旋转结果进行逆QPE，有

\[\begin{split}\begin{aligned} & (I\otimes{QPE}^{\dagger})\sum_{j=0}^{N-1}{(\sqrt{1-\frac{C^2}{{\widetilde{\lambda_j}}^2}}\left|0\right\rangle+\frac{C}{\widetilde{\lambda_j}} \left|1\right\rangle)b_j\left|\widetilde{\lambda_j}\right\rangle\left|u_j\right\rangle} \\ & =\sum_{j=0}^{N-1}{(b_j}\sqrt{1-\frac{C^2}{{\widetilde{\lambda_j}}^2}}\left|0\right\rangle\left|0\right\rangle\left|u_j\right\rangle+b_j \frac{C}{\widetilde{\lambda_j}}\left|1\right\rangle\left|0\right\rangle\left|u_j\right\rangle). \end{aligned}\end{split}\]

事实上即使是这种形式的结果量子态，由于误差的存在，依然无法在第一个和第二个量子寄存器分别为 \(\left|1\right\rangle,\left|0\right\rangle\) 的情况下以概率1得到解量子态 \(\left|x\right\rangle=\sum_{j=0}^{N-1}{\lambda_j^{-1}b_j\left|u_j\right\rangle}\) 。

Note

HHL算法充分利用了量子相位估计提取特征值信息的功能，巧妙构造了受控旋转门从存储比特的基向量中抓取特征值存入振幅， 最后利用逆相位估计还原存储量子比特，从而得到了振幅含特征值的方程解。

量子线路图与参考代码

HHL算法的量子线路图如下所示

基于QPanda-2.0的HHL算法实现代码较为冗长，此处不作详述，具体参见QPanda-2.0下HHL算法程序源码 ，此处仅介绍QPanda-2.0中提供的几个HHL算法调用接口。

QCircuit build_HHL_circuit(const QStat& A, const std::vector<double>& b, QuantumMachine *qvm);
QStat HHL_solve_linear_equations(const QStat& A, const std::vector<double>& b);

第一个函数接口用于得到HHL算法对应的量子线路，第二个函数接口则可以输入QStat格式的矩阵和右端项，返还解向量。

选取 \(A=\bigl(\begin{smallmatrix} 3.75 & 2.25 & 1.25 &-0.75 \\ 2.25 &3.75 & 0.75 & -1.25\\ 1.25 & 0.75 & 3.75 &-2.25 \\ -0.75 & -1.25 & -2.25 &3.75 \end{smallmatrix}\bigr), b=\begin{pmatrix} 0.5,0.5,0.5,0.5 \end{pmatrix}^T\) ， 验证HHL的代码实例如下

#include "QPanda.h"
using namespace QPanda;

int main(void)
{
   auto machine = initQuantumMachine(CPU);
   auto prog = QProg();

   QStat A = {
   qcomplex_t(15.0 / 4.0, 0), qcomplex_t(9.0 / 4.0, 0), qcomplex_t(5.0 / 4.0, 0), qcomplex_t(-3.0 / 4.0, 0),
   qcomplex_t(9.0 / 4.0, 0), qcomplex_t(15.0 / 4.0, 0), qcomplex_t(3.0 / 4.0, 0), qcomplex_t(-5.0 / 4.0, 0),
   qcomplex_t(5.0 / 4.0, 0), qcomplex_t(3.0 / 4.0, 0), qcomplex_t(15.0 / 4.0, 0), qcomplex_t(-9.0 / 4.0, 0),
   qcomplex_t(-3.0 / 4.0, 0), qcomplex_t(-5.0 / 4.0, 0), qcomplex_t(-9.0 / 4.0, 0), qcomplex_t(15.0 / 4.0, 0)
   };

   std::vector<double> b = { 0.5, 0.5, 0.5, 0.5 };

   QStat result = HHL_solve_linear_equations(A, b);
   int w = 0;
   double coffe = sqrt(340);
   for (auto& val : result)
   {
      val *= coffe;
      std::cout << val << " ";
      if (++w == 2)
      {
            w = 0;
            std::cout << std::endl;
      }
   }
   std::cout << std::endl;

   return 0;
}

由理论推导可以知道HHL算法对此问题求得的近似解会有较大误差，经典解为 \(\frac{1}{32}\begin{pmatrix} -1,7,11,13 \end{pmatrix}^T\)， 近似解为 \(\frac{1}{\sqrt{340}}\begin{pmatrix} -1,7,11,13 \end{pmatrix}^T\)，因此输出结果应当如下

-0.0542326
0.379628
0.596559
0.705024

Grover算法和量子计数算法

量子计数算法（Quantum Counting）与Grover算法都是基于集合元素二类划分问题衍生的算法。量子计数算法可以求得集合中两种类型元素的个数，Grover算法则可以求得指定类型的一个元素。

问题背景概述

前文中介绍了振幅放大量子线路的问题背景集合元素二类划分问题，即对于给定的有限集合和划分标准 \(\Omega,f\)，我们可以用如下量子态表示集合元素

\[\begin{aligned} \left|\psi\right\rangle=sin\theta\left|\varphi_1\right\rangle+cos\theta\left|\varphi_0\right\rangle, \ \left|\varphi_0\right\rangle=\left|\varphi_1^\bot\right\rangle. \end{aligned}\]

现在对此问题进行两种扩展。

量子计数问题

记 \(\left|\Omega\right|=N=2^n,\Omega\supseteq B, \left|B\right|=M\le N\)，且判别函数满足

\[\begin{split}\begin{aligned} \left\{\begin{matrix} f:\Omega\rightarrow\{0,1\},\\ f\left(x\right)=\left\{\begin{matrix} 1,x\in B,\\ 0,x\notin B. \end{matrix}\right. \end{matrix}\right. \end{aligned}\end{split}\]

求 \(M\)。

传统算法是简单地通过 \(O(N)\) 次的运算进行遍历计数，从而求得解的集合基数 \(M\)。量子计数算法的时间复杂度与QPE过程完全一致，均为 \(O\left(\left(\log_2{N}\right)^2\right)\)。

Note

将振幅放大算子应用到QPE线路中，可以起到类似于由特征量子态提取特征值的过滤提取作用。

解元素的搜索问题

集合 \(\Omega\) 中存在某个元素 \(\omega \in \Omega\) 为特定问题的解，判别函数的定义如下：

\[\begin{split}\begin{aligned} \left\{\begin{matrix} f:\Omega\rightarrow\{0,1\},\\ f\left(x\right)=\left\{\begin{matrix} 1,x=\omega,\\ 0,x \neq \omega. \end{matrix}\right. \end{matrix}\right. \end{aligned}\end{split}\]

求 \(\omega \in \Omega\) 。

Grover算法的过程与振幅放大量子线路的过程完全一致。Grover算法的时间复杂度为 \(O(\sqrt N)\)，相对于经典算法的O(N)有着极大加速。

Note

事实上，振幅放大得到振幅和基向量的近似求解的思想不局限于集合元素二类划分问题。

算法原理

两种算法需要预制备的集合元素量子态有着相似的如下形式

\[\begin{aligned} \left|\psi\right\rangle=sin\theta\left|\varphi_1\right\rangle+cos\theta\left|\varphi_0\right\rangle, \ \left|\varphi_0\right\rangle=\left|\varphi_1^\bot\right\rangle. \end{aligned}\]

但具体定义和需要求解的目标不同，因此基于振幅放大量子线路衍生出的算法原理也有所不同

基于振幅放大算子的QPE过程

量子计数算法中的两个基量子态是基于集合和判别函数定义的，即

\[\begin{aligned} \left|\varphi_0\right\rangle=\frac{1}{\sqrt{N-M}}\sum_{x\notin B}\left|x\right\rangle, \left|\varphi_1\right\rangle=\frac{1}{\sqrt M}\sum_{x\in B}\left|x\right\rangle. \end{aligned}\]

将问题转化到空间 \(\{\left|\varphi_0\right\rangle,\left|\varphi_1\right\rangle\}\) 上，不妨记 \(\sin{\theta}=\frac{\sqrt M}{\sqrt N}\) ，则需要求解 \(\theta\) 。

直接在空间 \(\{\left|\varphi_0\right\rangle,\left|\varphi_1\right\rangle\}\) 上定义振幅放大算子\(G=\left[\begin{matrix}\cos{2\theta}&-\sin{2\theta}\\\sin{2\theta}&\cos{2\theta}\\\end{matrix}\right]\)，满足

\[\begin{aligned} G(\cos{\theta}\left|\varphi_0\right\rangle+\sin{\theta}\left|\varphi_1\right\rangle) =\cos{3\theta}\left|\varphi_0\right\rangle+\sin{3\theta}\left|\varphi_1\right\rangle. \end{aligned}\]

振幅放大算子 \(G\) 的特征向量可以构成空间 \(\{\left|\varphi_0\right\rangle,\left|\varphi_1\right\rangle\}\) 的一组基向量，因此 \(\psi\) 可以拆解为 \(G\) 的特征向量的线性组合。

\(G\) 的特征值为 \(e^{\pm2i\theta}\)，借助在制备 \(\psi\) 的过程中使用的索引比特，可以准确区分出以 \(G\) 构造的QPE过程结果对应的特征子相位是 \(2\theta\) 或 \(2\pi-2\theta\)。

于是就可以通过基于 \(G\) 的QPE过程完成对 \(\theta\) 的求解，而 \(N\) 已知，于是完成了对 \(M\) 的求解。

Note

为什么可以判定振幅放大算子 \(G\) 的特征向量可以构成空间 \(\{\left|\varphi_0\right\rangle,\left|\varphi_1\right\rangle\}\) 的一组基向量？

基于镜像变换的振幅放大量子线路

对于给定的量子态 \(\left|\psi\right\rangle=sin\theta\left|\varphi_1\right\rangle+cos\theta\left|\varphi_0\right\rangle\)， 可以直接参考振幅放大量子线路，给出Grover算子，从而得到 \(\left|\psi_k\right\rangle=\sin{(2k+1)\theta} \left|\varphi_1\right\rangle+\cos{(2k+1)\theta}\left|\varphi_0\right\rangle,\ (2k+1)\theta\approx\frac{\pi}{2}\)。

但直接通过镜像变换构造的Grover算子 \(G=-(I-2\left|\omega\right\rangle \left\langle\omega\right|) (I-2\left|\psi\right\rangle \left\langle\psi\right|)\) 在实际的编程实现和运算过程中计算量过大，因此需要考虑如何将其利用基础的普适量子门简单实现累乘。

将原问题转换到空间 \(\{\left|\omega\right\rangle,\left|\psi\right\rangle\}\)left|Omegaright|=N`，由 \(\left\langle\varphi\middle|\omega\right\rangle=\frac{1}{\sqrt N}, \left\langle\varphi\middle|\varphi\right\rangle=1\) 可知

\[\begin{split}\begin{aligned} U_\omega=(I-2\left|\omega\right\rangle\langle\omega|)=\left[\begin{matrix}-1&-\frac{2}{\sqrt N}\\0&1\\\end{matrix}\right], U_s=2\left|\varphi\right\rangle\langle\varphi|-I=\left[\begin{matrix}-1&0\\\frac{2}{\sqrt N}&1\\\end{matrix}\right]. \end{aligned}\end{split}\]

记 \(\sin{\theta}=\frac{1}{\sqrt N},a=e^{i\theta},\ \ \frac{1}{\sqrt N}=\frac{a-a^{-1}}{2i}\)，于是有

\[\begin{split}\begin{aligned} U_\omega U_s=\frac{1}{a^2+1}\left[\begin{matrix}-i&i\\a&a^{-1}\\\end{matrix}\right]\left[\begin{matrix}a^2&0 \\0&a^{-2}\\\end{matrix}\right]\left[\begin{matrix}i&a\\-a^2i&a\\\end{matrix}\right]. \end{aligned}\end{split}\]

记 \(Q=U_sU_\omega\) ，有 \(Q\left|\varphi\right\rangle=\frac{N-4}{N}\left|\varphi\right\rangle +\frac{2}{\sqrt N}\left|\omega\right\rangle\) ，且

\[\begin{split}Q^k = \frac{1}{a^2+1}\left[\begin{matrix}-i&i\\a&a^{-1}\\\end{matrix} \right]\left[\begin{matrix}a^{2k}&0\\0&a^{-2k}\\\end{matrix}\right]\left[\begin{matrix}i&a\\-a^2i&a\\\end{matrix}\right].\end{split}\]

对 \(\left|\varphi\right\rangle\) 执行量子门 \(Q^k\) 后，测量第一个寄存器得到解量子态 \(\left|\omega\right\rangle\) 的概率为 \(P(\omega)={\langle\omega|Q}^k\left|\varphi\right\rangle=\left[\begin{matrix}\left\langle\omega|\omega\right\rangle &\left\langle\omega|\varphi\right\rangle\\\end{matrix}\right]{{{(U}_sU}_\omega)}^k\left[\begin{matrix}0\\1\\\end{matrix}\right] =\frac{a^{2k+1}-a^{-\left(2k+1\right)}}{2i}=\sin{(\left(2k+1\right)\theta)}\)。

解 \(\left(2k+1\right)\theta=\frac{\pi}{2}\) 可知经过 \(k=[\frac{\pi}{4}\arcsin^{-1}{\frac{1}{\sqrt N}}-\frac{1}{2}]≈O(N)\)次 \(Q\) 量子门操作后可以通过测量以逼近 \(1\) 的概率得到解 \(\left|\omega\right\rangle\)。

量子线路图与参考代码

量子计数算法和Grover算法的核心内容都是振幅放大算子，算法结构分别与QPE和振幅放大量子线路基本一致。

Quantum Counting算法的量子线路图如下所示

Grover算法的量子线路图如下所示

基于QPanda-2.0的实现量子计数算法的过程与QPE过程几乎没有区别，因此源码与Grover算法合并在一起，两种算法的程序实现可以参考 QPanda-2.0下Quantum Counting和Grover算法程序源码 。

下面对Grover算法介绍基于QPanda-2.0的一个接口函数和一个样例代码实现。Quantum Counting算法的程序实例不再赘述，与QPE的代码实现没有本质区别。

Note

基于集合 \(\Omega\) 和判别函数 \(f\) 的试验态制备是两种算法共同的重要前置工作，与振幅放大算子一起构成了算法的核心组件。

QProg grover_alg_search_from_vector(const std::vector<T> &data_vec,
   ClassicalCondition condition,
   std::vector<size_t> &result_index_vec,
   QuantumMachine * qvm,
   size_t repeat = 0)

输入参数分别为算法搜索空间、搜索条件、输出结果存储变量、量子模拟机以及迭代次数，返还一个可执行的Grover量子线路。 Grover算法还有其他的接口函数，此处不作赘述。

下面是 n=3情况下的Grover示例程序代码

#include "QPanda.h"
using namespace QPanda;

int main(void)
{
   auto machine = initQuantumMachine(CPU);
   auto x = machine->allocateCBit();
   std::vector<SearchDataByUInt> search_space;
   search_space.push_back(8);
   search_space.push_back(7);
   search_space.push_back(6);
   search_space.push_back(0);

   QVec measure_qubits;
   QProg grover_Qprog = build_grover_alg_prog(search_space, x == 6, machine, measure_qubits, 1);

   //measure
   printf("Strat pmeasure.\n");
   auto result = probRunDict(grover_Qprog, measure_qubits);

   printf("pmeasure result:\n");
   for (auto aiter : result)
   {
      if (0 == aiter.second)
      {
         continue;
      }
      printf("%s:%5f\n", aiter.first.c_str(), aiter.second);
   }

   destroyQuantumMachine(machine);

   return 0;
}

输出结果应当如下

10:1

Shor算法

Shor算法，又叫质因数分解算法，在破解RSA加密方面有着重要意义。

问题背景

已知一个大整数 \(N=pq\)，其中 \(p,q\) 均为未知的质数，求解 \(p,q\)。 Shor算法分为经典算法实现的公约数求解、将质因数分解转化为函数周期求解等部分，以及借助量子傅里叶变换等量子算法实现的函数周期求解共三个部分。

相对经典算法，Shor算法在计算资源耗费和计算时间复杂度两方面均有极大的降低，使经典算法无法求解的超大型质因子分解问题出现了量子算法求解的可能。

Note

Shor算法试图解决的极大比特数RSA问题使用经典算法在理论上所需的计算时间和空间资源是近乎无法满足的，它不再只体现了量子计算的相对优势，而是揭示了特定问题上量子计算的不可取代性和绝对优势。

算法原理

Shor分解算法的具体步骤如下：

1. \(\forall 1<x<N,\ x\in\mathbb{Z}\)；

2. \(gcd(x,N)\neq 1\)，结束；

3. 求 \(r\) 使得 \(x^r mod N≡1\)；

4. \(r\ mod\ 2\equiv1\)，回到1取 \(\dot{x}≠x\)；

5. \(x^\frac{r}{2}\ mod\ N\equiv-1\)，回到1取 \(\dot{x}≠x\)；

6. \(gcd(x^\frac{r}{2}-1,N)gcd(x^\frac{r}{2}+1,N)=N\)。

式中 \(gcd\) 表示最大公约数（Greatest Common Divisor）。

以上步骤中，难点集中在第三步指定余数1的模指逆元求解。 将第三步转化为如下问题，并采用量子算法求解：

记 \(f\left(x\right)=x^a\mathrm{\ mod\ N},f\left(a+r\right)=f\left(a\right)\)，求最小的 \(r\) 。

下面介绍模指逆元求解的量子算法的核心内容，主要有三个部分。

1. 公式变形所需的前置引理。

2. 构造出可用的模乘量子门操作以迭代完成模指逆元量子态构建。

3. 参考QPE对构造出的模乘求和形式的结果以逆量子傅里叶变换得到模指逆元。

限于篇幅，第一部分中的前置引理将只作介绍而不加以证明。

前置引理

定义

\[\begin{aligned} \left|u_s\right\rangle\equiv\frac{1}{\sqrt{r}}\Sigma_{k=0}^{r-1}e^{-\frac{2\pi\ iks}{r}}\left|x^k\ mod N\right\rangle,\ x^rmod\ N\equiv1. \end{aligned}\]

引理1：

\[\begin{aligned} \frac{1}{\sqrt{r}}\Sigma_{s=0}^{r-1}e^\frac{2\pi\ iks}{r}\left|u_s\right\rangle=\left|x^k\ modN\right\rangle. \end{aligned}\]

引理2：

\[\begin{aligned} \exists U,U\left|y\right\rangle=\left|xy\ modN\right\rangle,s.t.U\left|u_s\right\rangle=e^\frac{2\pi is}{r}\left|u_s\right\rangle. \end{aligned}\]

引理3：

\[\begin{aligned} \frac{1}{\sqrt{r}}\Sigma_{s=0}^{r-1}\left|u_s\right\rangle=\left|1\right\rangle. \end{aligned}\]

有了引理1、2和3，我们就可以将模指量子态、定义的特殊量子态 \(\left|u_s\right\rangle\)、基态 \(\left|1\right\rangle\) 以及模指逆元 \(r\) 通过量子傅里叶变换/逆变换、\(\left|u_s\right\rangle\) 的定义变换/逆变换全部关联起来。

构造模乘量子门

定义量子门操作 \(U^j\left|y\right\rangle=\left|yx^j\ modN\right\rangle\)。

对任给整数 \(Z\)，对其进行 \(t\) 位数二进制展开可知

\[\begin{aligned} U^{2^{t-1}z_{t-1}}U^{2^{t-2}z_{t-2}}\cdots U^{2^0z_0}\left|1\right\rangle\approx\left|1\ast x^z\ modN\right\rangle. \end{aligned}\]

由上式可以利用模乘量子门来实现模指操作。

求解模指逆元

考察两个寄存器组成的量子态 \(\left|0\right\rangle^{\otimes t}(\left|0\right\rangle^{\otimes L-1} \left|1\right\rangle){=\left|0\right\rangle^{\otimes t}\left|1\right\rangle}_L\)，将第一个寄存器初始化为最大叠加态，有

\[\begin{aligned} (H^{\otimes t}{\otimes I^{\otimes L})(\left|0\right\rangle}^{\otimes t}\left|1\right\rangle_L) =\left|+\right\rangle^{\otimes t}\otimes\left|1\right\rangle_L. \end{aligned}\]

基于量子门操作 \(U^j\) 可以定义受控模乘量子门 \(C-U^j\)。取 \(\left|+\right\rangle^{\otimes t}\) 的第j项作为控制比特对 \(\left|+\right\rangle^{\otimes t}\otimes\left|1\right\rangle_L\) 执行 \(t\) 次 \(C-U^{2^{j-1}}\) 完成受控模指量子门操作，有

\[\begin{split}\begin{aligned} &\prod_{j=1}^{t}\left(C-U^{2^{j-1}}\right)\left(\left|+\right\rangle^{\otimes t}\otimes\left|1\right\rangle_L\right)\\ & =\frac{1}{{\sqrt2}^t}\sum_{j=0}^{2^t-1}\left|j\right\rangle\left|x^j\ modN\right\rangle \\ & =\frac{1}{\sqrt{r2^t}}{\Sigma_{j=0}^{2^t-1}\Sigma}_{s=0}^{r-1}e^\frac{2\pi\ ijs}{r} \left|j\right\rangle\left|u_s\right\rangle=:\left|\psi\right\rangle. \end{aligned}\end{split}\]

对第一个寄存器进行IQFT，有

\[\begin{aligned} ({\rm QFT}^{-1}\otimes I^{\otimes L})\left|\psi\right\rangle=\frac{1}{\sqrt r}\Sigma_{s=0}^{r-1} \left|\frac{2^ts}{r}\right\rangle\left|u_s\right\rangle. \end{aligned}\]

测量第一个寄存器得到任意一个非 \(\left|0\right\rangle\) 量子态，进而有最逼近实数 \(\frac{2^ts}{r}\) 的整数\([\frac{2^ts}{r}]\)，对实数 \(\frac{[\frac{2^ts}{r}]}{2^t}\) 进行连续分数展开得到 \(\frac{s}{r}\)，自然可以获得分母 \(r\)。

此处 \(L=n={[\log}_2N]\)，如果取 \(t=2n+1+[log(2+\frac{1}{2\varepsilon})]\)，那么可以得到二进制展开精度为 \(2n+1\) 位的相位估计结果，且测量得到该结果的概率至少为 \(\frac{1-\varepsilon}{r}\)。一般取 \(t=2n\)。

量子线路图与参考代码

Shor算法的量子线路图如下所示

基于QPanda-2.0的Shor算法源码参见QPanda-2.0下Shor算法程序源码 ，此处仅介绍QPanda-2.0中提供的Shor算法调用接口。

std::pair<bool, std::pair<int,int>> Shor_factorization(int target);

输入参数为被质因数分解的大数，返还计算过程是否成功和分解后的质因子对。

选取 \(N=15\) ， 验证Shor的代码实例如下

#include "QPanda.h"
using namespace QPanda;

int main(void)
{
   int N = 15, factor_1, factor_2;
   auto p = Shor_factorization(N);
   cout << boolalpha << p.first << "," << p.second.first << "," << p.second.second << endl;

   return 0;
}

对 \(15\) 的质因子分解结果应该是 \(15=3*5\) ，所以应当返还算法成功标志和两个质因子 \(3\) 和 \(5\) 。

true, 3, 5

量子虚时演化算法

虚时演化（Imaginary time evolution）是研究量子系统的一个有力工具。虚时演化算法作为一种量子经典混合算法对于任意一个给定哈密顿量H的系统均可以近似求解得到其基态向量，即哈密顿量 :math:`H`的最小特征值对应的特征向量。此算法的量子线路浅易于实现，应用范围广泛，可以求解一些经典算法难以解决的问题。

问题背景概述

对于给定哈密顿量 \(H\) 的系统，随着时间 \(t\)，系统根据传播变换（propagator） \(e^{-iHt}\) 演化。对应的虚时 \((\tau=it)\) 传播变换为 \(e^{-Ht}\)，是一个非幺正算符。

给定哈密顿量 \(H\) 和初态 \(\left|\psi\right\rangle\) ,归一化的虚时演化被定义为

\[\begin{aligned} \left|\psi\left(\tau\right)\right\rangle=A\left(\tau\right)e^{-Ht}\left|\psi\left(0\right)\right\rangle, A\left(\tau\right)=\left({\langle\psi\left(0\right)|e}^{-2Ht} \left|\psi\left(0\right)\right\rangle\right)^\frac{1}{2}. \end{aligned}\]

\(A\left(\tau\right)\) 为归一化因子，通常多体系统的哈密顿量 \(H=\sum_{i}{\lambda_ih_i}\), 其中 \(\lambda_i\) 为实系数，\(h_i\) 为可观测量（observables）并且可以表示为Pauli矩阵的直积。

于是有如下的等价薛定谔方程：

\[\begin{aligned} \frac{\partial\left|\psi\left(\tau\right)\right\rangle}{\partial\tau} =-\left(H-\frac{A^\prime\left(\tau\right)}{A\left(\tau\right)}\right)\left|\psi\left(\tau\right)\right\rangle =-\left(H-E_\tau\right)\left|\psi\left(\tau\right)\right\rangle. \end{aligned}\]

Note

实际应用中，QITE的真正难点在于如何将原问题转化为哈密顿系统求基态问题，以及如何对哈密顿系统给出其哈密顿量。

算法原理

量子虚时演化算法由2个部分：

1. 通过给定的问题系统哈密顿量，构造相应的薛定谔方程，将薛定谔方程求解问题转化为一个线性方程组求解问题；

2. 求解线性方程组，得到关键变量的时间演化函数，利用虚时演化的特性求得系统最低能量情况下对应的基态，完成对问题的求解。

量子虚时演化算法可用于在任意已知哈密顿量的哈密顿系统由初态求解任意时刻状态及最终稳态。

从薛定谔方程到微分方程近似解

考虑给定的哈密顿量 \(H\) 所满足的Wick旋转薛定谔方程

\[\begin{aligned} (\frac{\partial}{\partial\tau}-\left(H-E_\tau\right))\left|\psi\left(\tau\right)\right\rangle=0, E_\tau=\left\langle\psi(\tau)\right|H\left|\psi(\tau)\right\rangle. \end{aligned}\]

应用McLachlan变分原理，有

\[\begin{aligned} \delta \left \| \left(\frac{\partial}{\partial\tau}-\left(H-E_\tau\right)\right) \left|\psi\left(\tau\right)\right\rangle \right \|=0. \end{aligned}\]

以测试态 \(\left|\phi\left(\vec{\theta}\left(\tau\right)\right)\right\rangle, \vec{\theta}\left(\tau\right)=\left(\theta_1\left(\tau\right),\theta_2\left(\tau\right), \cdots,\theta_N\left(\tau\right)\right)\) 逼近解 \(\left|\psi\left(\tau\right)\right\rangle\)。

记 \(\dot{\theta_j}=\frac{\partial\theta_j}{\partial\tau}, S=\left(\frac{\partial}{\partial\tau}-\left(H-E_\tau\right)\right)\) ，同时考虑到归一化条件\(\left\langle\phi|\phi\right\rangle=1\)，有

\[\begin{split}\begin{aligned} &\frac{\partial\left \| S\left|\phi\left(\tau\right)\right\rangle \right \|}{\partial\dot{\theta_i}} \\ &=\sum_{i,j}\frac{\partial\left\langle\phi\right|}{\partial\theta_i} \frac{\partial\left|\phi\right\rangle}{\partial\theta_j}\dot{\theta_j} +\sum_{i}{(\frac{\partial\left\langle\phi\right|}{\partial\theta_i}}H\left|\phi\right\rangle +\left\langle\phi\right|H\frac{\partial\left|\phi\right\rangle}{\partial\theta_i}) \\ &=\sum_{j} A_{ij}\dot{\theta_j}-C_j=0. \end{aligned}\end{split}\]

其中

\[\begin{split}\begin{aligned} &A_{ij}=Re\left(\frac{\partial\left\langle\phi\right|}{\partial\theta_i}\frac{\partial\left|\phi\right\rangle}{\partial\theta_i}\right),\\ &C_i=-Re\left(\frac{\partial\left\langle\phi\right|}{\partial\theta_i}H\left|\phi\right\rangle\right). \end{aligned}\end{split}\]

于是原薛定谔方程转化为解为 \(\dot{\theta_j}\) 的线性方程组。

虚时演化逼近基态

由 \(x^\dagger Ax > 0\) 可知 \(A\) 是正定的，其广义逆 \(A^{-1}\) 也是正定的。

于是对系统的平均能量 \(E_\tau\) 有

\[\begin{split}\begin{aligned} &\frac{{dE}_\tau}{d\tau}=\frac{d\left\langle\psi\left(\tau\right)\left|H\right|\psi\left(\tau\right)\right\rangle}{d\tau}\\ &=\sum_{i}{Re\left(\frac{\partial\left\langle\phi\right|}{\partial\theta_i}H\left|\phi\right\rangle\dot{\theta_i}\right) =-\sum_{i} C_i\dot{\theta_i}}=-\sum_{i,j} C_iA_{i,j}^{-1}C_j\le0. \end{aligned}\end{split}\]

可知运用此量子虚时演化算法会使整个系统的平均能量不断减小。

记测试态 \(\left|\phi\left(\vec{\theta}\right)\right\rangle=V\left(\vec{\theta}\right)\left|\bar{0}\right\rangle =U_N\left(\theta_N\right)\cdots U_2\left(\theta_2\right)U_1\left(\theta_1\right)\left|\bar{0}\right\rangle\)，其中\(U_i\) 为幺正算符，\(\bar{0}\) 为系统的初态（并不是基态 \(\left|0\right\rangle\)）。

不失一般性地，可以假设每个U_i均仅依赖于一个参数theta_i（否则可以进行量子门操作分解），不妨假设每个 \(U_i\) 均为旋转或受控旋转门，于是其导数可以表示为 \(\frac{{\partial U}_i\left(\theta_i\right)}{\partial\theta_i} =\sum_{k}{f_{k,i}U_i\left(\theta_i\right)\sigma_{k,i}}\)。其中 \(\delta_{k,i}\) 为幺正算符，\(f_{k,i}\) 为标量函数，于是测试态的导数可以表示为 \(\frac{\partial\phi\left(\tau\right)}{\partial\theta_i} =\sum_{k}{f_{k,i}{\widetilde{V}}_{k,i}\left|\bar{0}\right\rangle}\)。其中\({\widetilde{V}}_{k,i}=U_N\left(\theta_N\right)\cdots U_{i+1}\left(\theta_{i+1}\right) U_i\left(\theta_i\right)\sigma_{k,i}{\cdots U}_2\left(\theta_2\right)U_1\left(\theta_1\right)\)。

于是对于微分方程组 \(\sum_{j} A_{ij}\dot{\theta_j}=C_j\) 有

\[\begin{split}\begin{aligned} A_{ij}=Re\left(\sum_{k,l}{f_{k,i}^\ast f_{l,i}\langle\bar{0}|{\widetilde{V}}_{k,i}^\dagger{\widetilde{V}}_{l,j} \left|\bar{0}\right\rangle}\right),\\ C_i=-Re\left(\sum_{k,l}{f_{k,i}^\ast\lambda_l\langle\bar{0}|{\widetilde{V}}_{k,i}^\dagger h_lV \left|\bar{0}\right\rangle}\right). \end{aligned}\end{split}\]

以上两个表达式均符合一般形式 \(aRe\left(e^{i\theta}\langle0|U\left|\bar{0}\right\rangle\right)\)，因而可以使用量子线路对其进行构造，\(A_{ij}\) 的构造方式如下：

\[\begin{aligned} \mathrm{\langle}\bar{\mathrm{0}}|{\widetilde{V}}_{k,i}^\dagger{\widetilde{V}}_{l,j}\left|\bar{\mathrm{0}}\right\rangle \mathrm{=\langle}\bar{\mathrm{0}}\mathrm{|}\mathrm{U}_1^\dagger\cdots\mathrm{U}_{i-1}^\dagger\sigma_{k,i}^\dagger \mathrm{U}_i^\dagger\cdots\mathrm{U}_{j-1}^\dagger{\sigma_{i,j}\mathrm{U} }_j^\dagger\cdots U_1\left|\bar{\mathrm{0}}\right\rangle. \end{aligned}\]

对 \(C_{ij}\) 有类似结果，于是可以用量子线路构造 \(A_{ij}, C_{ij}\) 。

因此可以引入线性方程组的量子算法，完成求解后得到 \(\dot{\theta_j}=\frac{\partial\theta_j}{\partial\tau}\)， 进而将 \(\phi\left(\vec{\theta}\right)\) 进行虚时演化，可以得到系统稳定状态下的基态 \(\theta\)。

于是完成了对于任意给定的哈密顿量 \(H\) 对应的系统基态的近似求解。

量子线路图与参考代码

QITE算法中构造线性方程组的左端项矩阵和右端项的量子线路图如下所示

基于QPanda-2.0的QITE算法实现代码参见QPanda-2.0下QITE算法程序源码 ，QPanda-2.0中QITE算法相关代码是一个类，因而下面将介绍所有相关的输入输出接口函数。

QITE();
void setHamiltonian(const PauliOperator& h)
void setAnsatzGate(const std::vector<AnsatzGate>& ansatz_gate)
void setIterNum(size_t num)
void setDeltaTau(double delta_tau)
void setUpthrowNum(size_t num)
void setParaUpdateMode(UpdateMode mode)
int exec();
prob_tuple getResult();

以上函数中，第一个函数为类的构造函数，后续6个函数作用分别为设置哈密顿量，拟设、迭代数、\(\tau\) 的变化率、重置迭代次数、收敛模式参考梯度值或梯度方向、执行虚时演化和获得列表格式的概率结果。

我们可以将量子变分虚时演化算法应用到网络节点重要性排序问题上，综合已有结论快速求解得到节点的重要性权重。选择如下图所示的网络节点重要性排序问题进行代码实现，

此问题的QITE求解代码实例如下

#include "QPanda.h"
using namespace QPanda;

int main(void)
{
   std::vector<std::vector<double>> node7graph{
     // A  B  C  D  E  F  G
       {0, 1 ,0 ,0, 0, 0, 0},
       {1, 0 ,1 ,0, 0, 0, 0},
       {0, 1 ,0 ,1, 1, 1, 0},
       {0, 0 ,1 ,0, 1, 0, 1},
       {0, 0 ,1 ,1, 0, 1, 1},
       {0, 0 ,1 ,0, 1, 0, 1},
       {0, 0 ,0 ,1, 1, 1, 0}
   };

   std::vector< std::vector<std::vector<double>>> graph_vec;

   graph_vec.push_back(node7graph);

   for (int g = 0; g < graph_vec.size(); g++)
   {
      auto graph = graph_vec[g];
      auto node_num = graph.size();

      std::cout << node_num << " graph" << std::endl;

      NodeSortProblemGenerator problem;
      problem.setProblemGraph(graph);
      problem.exec();
      auto ansatz_vec = problem.getAnsatz();

      size_t cnt_num = 1;
      size_t iter_num = 100;
      size_t upthrow_num = 3;
      double delta_tau = 2.6;
      QITE::UpdateMode update_mode = QITE::UpdateMode::GD_DIRECTION;

      srand((int)time(0));
      for (auto cnt = 0; cnt < cnt_num; cnt++)
      {
            std::string log_filename = std::to_string(node_num) + "_num_" +
               std::to_string(cnt) + "_tau_" + std::to_string(delta_tau);

            std::fstream fout;
            fout.open(log_filename + "_init_para.txt", std::ios::out);
            for (auto i = 0; i < ansatz_vec.size(); i++)
            {
               ansatz_vec[i].theta = (rand() / double(RAND_MAX)) * 2 * PI;
               fout << ansatz_vec[i].theta << std::endl;
            }
            fout.close();

            QITE qite;
            qite.setHamiltonian(problem.getHamiltonian());
            qite.setAnsatzGate(ansatz_vec);
            qite.setIterNum(iter_num);
            qite.setDeltaTau(delta_tau);
            qite.setUpthrowNum(upthrow_num);
            qite.setParaUpdateMode(update_mode);
            qite.setLogFile(log_filename);
            auto ret = qite.exec();
            if (ret != 0)
            {
               return ret;
            }
            qite.getResult();
      }
   }

   return 0;
}

可以直接推导得知此7点网络图的节点重要性最大的节点应当为3号，因此结果应当抛出最重要节点3，写法为 \(00000100:1.00\)，如下所示的输出结果符合预期。

00000100 0.999931

=

Components

ChemiQ

class QPanda::Psi4Wrapper

Overview

wrapper class for Psi4. More…

#include <Psi4Wrapper.h>

class Psi4Wrapper
{
public:
    // methods

    void setMolecule(const std::string& molecule);
    std::string getMolecule();
    void setMultiplicity(int multiplicity);
    int getMultiplicity();
    void setCharge(int charge);
    int getCharge();
    void setBasis(const std::string basis);
    std::string getBasis();
    void setEqTolerance(const double val);
    double getEqTolerance();
    std::string getLastError();
    std::string getData();
    void initialize(const std::string& dir);
    bool run();
    void finalize();
};

Detailed Documentation

wrapper class for Psi4.

Methods

void setMolecule(const std::string& molecule)

set molecule

Parameters:

string&

the name of molecule

std::string getMolecule()

get molecule

Returns:

the name string of the molecule

void setMultiplicity(int multiplicity)

set multiplicity

Parameters:

int	multiplicity val

int getMultiplicity()

get multiplicity

Returns:

return the val of the multiplicity

void setCharge(int charge)

set charge

Parameters:

int	charge val

int getCharge()

get charge

Returns:

return the val of charge

void setBasis(const std::string basis)

set Basis

Parameters:

std::string

the string of Basis

std::string getBasis()

get Basis

Returns:

return the val of Basis

void setEqTolerance(const double val)

set Eq Tolerance

Parameters:

double

the val of Tolerance

double getEqTolerance()

get Eq Tolerance

Returns:

return the val of Tolerance

std::string getLastError()

get last error string

Returns:

return the last error string

std::string getData()

get the data

Returns:

return the data string

void initialize(const std::string& dir)

Initialize.

Parameters:

std::string&

the dir of chemiq

bool run()

run Psi4

void finalize()

release resource

Overview

// classes

class QPanda::Psi4Wrapper;

// global functions

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

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

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

Detailed Documentation

Global Functions

DLLEXPORT size_t QPanda::getElectronNum(const std::string& atom)

get the electron number of the atom.

Parameters:

std::string&

atom

Returns:

size_t atom’s electorn number

DLLEXPORT PauliOperator QPanda::JordanWignerTransform(const OrbitalActVec& fermion_item)

Jordan-Wigner transform of one fermion term, like “3+ 1 2+ 0”.

Parameters:

OrbitalActVec&

fermion term

Returns:

PauliOperator

See also:

OrbitalActVec

PauliOperator

DLLEXPORT PauliOperator QPanda::JordanWignerTransform(const FermionOperator& fermion)

Jordan-Wigner transform from FermionOperator to PauliOperator.

Parameters:

FermionOperator&

fermion operator

Returns:

PauliOperator

See also:

FermionOperator

PauliOperator

DLLEXPORT VarPauliOperator QPanda::JordanWignerTransform(const VarFermionOperator& fermion)

Jordan-Wigner transform from VarFermionOperator to VarPauliOperator.

Parameters:

VarFermionOperator&

variational fermion operator

Returns:

VarPauliOperator

See also:

VarFermionOperator

VarPauliOperator

DLLEXPORT PauliOperator QPanda::ParityTransform(const OrbitalActVec& fermion_item, size_t maxqubit)

Parity transform of one fermion term, like “3+ 1 2+ 0”.

Parameters:

OrbitalActVec&	fermion term
size_t	maxqubit

Returns:

PauliOperator

See also:

OrbitalActVec

PauliOperator

DLLEXPORT PauliOperator QPanda::ParityTransform(const FermionOperator& fermio)

Parity transform from FermionOperator to PauliOperator.

Parameters:

FermionOperator&

fermion operator

Returns:

PauliOperator

See also:

FermionOperator

PauliOperator

DLLEXPORT VarPauliOperator QPanda::ParityTransform(const VarFermionOperator& fermion)

Parity transform from VarFermionOperator to VarPauliOperator.

Parameters:

VarFermionOperator&

variational fermion operator

Returns:

VarPauliOperator

See also:

VarFermionOperator

VarPauliOperator

DLLEXPORT std::vector<Eigen::MatrixXi> QPanda::BKMatrix(size_t qn)

BKMatrix required by BravyiKitaev transform.

Parameters:

size_t

qn quantum number

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

BravyiKitaev transform of one fermion term, like “3+ 1 2+ 0”.

Parameters:

OrbitalActVec&	fermion term
size_t	maxqubit
std::vector<Eigen::MatrixXi>	BK

Returns:

PauliOperator

See also:

OrbitalActVec

PauliOperator

DLLEXPORT VarPauliOperator QPanda::BravyiKitaevTransform(
    const VarFermionOperator& fermion,
    std::vector<Eigen::MatrixXi> BK
    )

BravyiKitaev transform from VarFermionOperator to VarPauliOperator.

Parameters:

VarFermionOperator&	variational fermion operator
std::vector<Eigen::MatrixXi>	BK

Returns:

VarPauliOperator

See also:

VarFermionOperator

VarPauliOperator

DLLEXPORT size_t QPanda::getCCS_N_Trem(size_t qn, size_t en)

get CCS term number.

Coupled cluster single model. e.g. 4 qubits, 2 electrons then 0 and 1 are occupied,just consider 0->2,0->3,1->2,1->3

Parameters:

size_t	quantum number(orbital number)
size_t	electron number

Returns:

size_t CCS term number

DLLEXPORT size_t QPanda::getCCSD_N_Trem(size_t qn, size_t en)

get CCSD term number.

Coupled cluster single and double model. e.g. 4 qubits, 2 electrons then 0 and 1 are occupied,just consider 0->2,0->3,1->2,1->3,01->23

Parameters:

size_t	quantum number(orbital number)
size_t	electron number

Returns:

size_t CCSD term number

DLLEXPORT FermionOperator QPanda::getCCS(size_t qn, size_t en, const vector_d& para_vec)

get Coupled cluster single model.

Coupled cluster single model. e.g. 4 qubits, 2 electrons then 0 and 1 are occupied,just consider 0->2,0->3,1->2,1->3. returned FermionOperator like this: {{“2+ 0”:para0},{“3+ 0”:para1},{“2+ 1”:para2},{“3+ 1”:para3}}

Parameters:

size_t	quantum number(orbital number)
size_t	electron number
vector_d&	parameters

Returns:

FermionOperator

DLLEXPORT VarFermionOperator QPanda::getCCS(size_t qn, size_t en, var& para)

get Coupled cluster single model with variational parameters.

Coupled cluster single model. e.g. 4 qubits, 2 electrons then 0 and 1 are occupied,just consider 0->2,0->3,1->2,1->3. returned FermionOperator like this: {{“2+ 0”:var[0]},{“3+ 0”:var[1]},{“2+ 1”:var[2]},{“3+ 1”:var[3]}}

Parameters:

size_t	quantum number(orbital number)
size_t	electron number
var	parameters

Returns:

VarFermionOperator

DLLEXPORT VarFermionOperator QPanda::getCCS(size_t qn, size_t en, std::vector<var>& para)

get Coupled cluster single model with variational parameters.

Coupled cluster single model. e.g. 4 qubits, 2 electrons then 0 and 1 are occupied,just consider 0->2,0->3,1->2,1->3. returned FermionOperator like this: {{“2+ 0”:var[0]},{“3+ 0”:var[1]},{“2+ 1”:var[2]},{“3+ 1”:var[3]}}

Parameters:

size_t	quantum number(orbital number)
size_t	electron number
std::vector<var>&	parameters

Returns:

VarFermionOperator

DLLEXPORT FermionOperator QPanda::getCCSD(size_t qn, size_t en, const vector_d& para_vec)

get Coupled cluster single and double model.

Coupled cluster single and double model. e.g. 4 qubits, 2 electrons then 0 and 1 are occupied,just consider 0->2,0->3,1->2,1->3,01->23. returned FermionOperator like this: {{“2+ 0”:para0},{“3+ 0”:para1},{“2+ 1”:para2},{“3+ 1”:para3}, {“3+ 2+ 1 0”:para5}}

Parameters:

size_t	quantum number(orbital number)
size_t	electron number
vector_d&	parameters

Returns:

FermionOperator

DLLEXPORT VarFermionOperator QPanda::getCCSD(size_t qn, size_t en, var& para)

get Coupled cluster single and double model with variational parameters.

Coupled cluster single and double model. e.g. 4 qubits, 2 electrons then 0 and 1 are occupied,just consider 0->2,0->3,1->2,1->3,01->23. returned FermionOperator like this: {{“2+ 0”:var[0]},{“3+ 0”:var[1]},{“2+ 1”:var[2]},{“3+ 1”:var[3]}, {“3+ 2+ 1 0”:var[4]}}

Parameters:

size_t	quantum number(orbital number)
size_t	electron number
var&	parameters

Returns:

VarFermionOperator

DLLEXPORT VarFermionOperator QPanda::getCCSD(size_t qn, size_t en, std::vector<var>& para)

get Coupled cluster single and double model with variational parameters.

Coupled cluster single and double model. e.g. 4 qubits, 2 electrons then 0 and 1 are occupied,just consider 0->2,0->3,1->2,1->3,01->23. returned FermionOperator like this: {{“2+ 0”:var[0]},{“3+ 0”:var[1]},{“2+ 1”:var[2]},{“3+ 1”:var[3]}, {“3+ 2+ 1 0”:var[4]}}

Parameters:

size_t	quantum number(orbital number)
size_t	electron number
std::vector<var>&	parameters

Returns:

VarFermionOperator

DLLEXPORT PauliOperator QPanda::transCC2UCC(const PauliOperator& cc)

Generate Hamiltonian form of unitary coupled cluster based on coupled cluster,H=1j*(T-dagger(T)), then exp(-jHt)=exp(T-dagger(T)).

Parameters:

PauliOperator&

pauli operator

Returns:

PauliOperator

See also:

PauliOperator

DLLEXPORT VarPauliOperator QPanda::transCC2UCC(const VarPauliOperator& cc)

Generate Hamiltonian form of unitary coupled cluster based on coupled cluster,H=1j*(T-dagger(T)), then exp(-jHt)=exp(T-dagger(T)).

Parameters:

VarPauliOperator&

pauli operator

Returns:

VarPauliOperator

See also:

VarPauliOperator

DLLEXPORT VQC QPanda::simulateHamiltonian(
    QVec& qubit_vec,
    VarPauliOperator& pauli,
    double t,
    size_t slices
    )

Simulate a general case of hamiltonian by Trotter-Suzuki approximation. U=exp(-iHt)=(exp(-i H1 t/n)*exp(-i H2 t/n))^n.

Parameters:

QVec&	the qubit needed to simulate the Hamiltonian
VarPauliOperator&	Hamiltonian
double	time
size_t	the approximate slices

Returns:

VQC

See also:

QVec

VarPauliOperator

QPanda::Variational::VQC

DLLEXPORT VQC QPanda::simulateOneTerm(
    QVec& qubit_vec,
    const QTerm& hamiltonian_term,
    const var& coef,
    double t
    )

Simulate a single term of Hamilonian like “X0 Y1 Z2” with coefficient and time. U=exp(-it*coef*H)

Parameters:

QVec&	the qubit needed to simulate the Hamiltonian
QTerm&	Hamiltonian term, string like “X0 Y1 Z2”
var&	the coefficient of hamiltonian
double	time

Returns:

VQC

See also:

QVec

QTerm

QPanda::Variational::var

DLLEXPORT VQC QPanda::simulateZTerm(QVec& qubit_vec, const var& coef, double t)

Simulating z-only term like H=coef * (Z0..Zn-1) U=exp(-iHt)

Parameters:

QVec&	the qubit needed to simulate the Hamiltonian
var&	the coefficient of hamiltonian
double	time

Returns:

VQC

See also:

QVec

QPanda::Variational::var

DLLEXPORT FermionOperator QPanda::parsePsi4DataToFermion(const std::string& data)

Parse psi4 data to fermion operator.

Parameters:

std::string&

fermon str

Returns:

FermionOperator

See also:

FermionOperator

HamiltonianSimulation

Overview

// global functions

QCircuit QPanda::simulateZTerm(const std::vector<Qubit*>& qubit_vec, double coef, double t);

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

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

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

Detailed Documentation

Global Functions

QCircuit QPanda::simulateZTerm(const std::vector<Qubit*>& qubit_vec, double coef, double t)

Simulating z-only term like H=coef * (Z0..Zn-1) U=exp(-iHt)

Z-Hamiltonian spreads over the qubit_vec

Parameters:

std::vector<Qubit*>&	the qubit needed to simulate the Hamiltonian
double	the coefficient of hamiltonian
double	time

Returns:

QCircuit

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

Simulate a single term of Hamilonian like “X0 Y1 Z2” with coefficient and time. U=exp(-it*coef*H)

Parameters:

std::vector<Qubit*>&	the qubit needed to simulate the Hamiltonian
QTerm&	hamiltonian_term: string like “X0 Y1 Z2”
double	coef: the coefficient of hamiltonian
double	t time

Returns:

QCircuit

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

Simulate a general case of hamiltonian by Trotter-Suzuki approximation. U=exp(-iHt)=(exp(-i H1 t/n)*exp(-i H2 t/n))^n.

Parameters:

std::vector<Qubit*>&	qubit_vec: the qubit needed to simulate the Hamiltonian
QHamiltonian&	hamiltonian: Hamiltonian
double	t: time
size_t	slices: the approximate slices

Returns:

QCircuit

QCircuit QPanda::simulatePauliZHamiltonian(
    const std::vector<Qubit*>& qubit_vec,
    const QHamiltonian& hamiltonian,
    double t
    )

Simulate hamiltonian consists of pauli-Z operators.

Parameters:

std::vector<Qubit*>&	qubit_vec: the qubit needed to simulate the Hamiltonian
QHamiltonian&	hamiltonian: Hamiltonian
double	t: time

Returns:

QCircuit

QCircuit QPanda::applySingleGateToAll(
    const std::string& gate,
    const std::vector<Qubit*>& qubit_vec
    )

Apply single gates to all qubits in qubit_list.

Parameters:

std::string&	gate: single gate name.
std::vector<Qubit*>&	qubit_vec: qubit vector

Returns:

QCircuit

void QPanda::applySingleGateToAll(
    const std::string& gate,
    const std::vector<Qubit*>& qubit_vec,
    QCircuit& circuit
    )

Apply single gates to all qubits in qubit_list and insert into circuit.

Parameters:

std::string&	gate: single gate name.
std::vector<Qubit*>&	qubit_vec: qubit vector
QCircuit&	circuit: operated circuit.

Returns:

QCircuit QPanda::ising_model(
    const std::vector<Qubit*>& qubit_vec,
    const QGraph& graph,
    const vector_d& gamma
    )

Ising model.

Parameters:

std::vector<Qubit*>&	qubit_vec: qubit vector
QGraph&	graph: the problem graph
vector_d&	gamma: model para

Returns:

QCircuit

QCircuit QPanda::pauliX_model(const std::vector<Qubit*>& qubit_vec, const vector_d& beta)

pauli X model

Parameters:

std::vector<Qubit*>&	qubit_vec: qubit vector
vector_d&	beta: model para

Returns:

QCircuit

MaxCutProblemGenerator

Overview

// global functions

double QPanda::vector_dot(std::vector<double>& x, std::vector<double>& y);

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

Detailed Documentation

Global Functions

double QPanda::vector_dot(std::vector<double>& x, std::vector<double>& y)

vector dot product

Parameters:

std::vector<double>&	vector x, x will be clear
std::vector<double>&	vector y, y will be clear

Returns:

double the dot product result of the two input vectors

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

all cut of graph

Parameters:

std::vector<std::vector<double>>	the adjacent matrix
std::vector<double>&	all cut list
std::vector<size_t>&	target value list

Returns:

double the max cut value

Operator

template class QPanda::FermionOp

Overview

Fermion operator class. More…

#include <FermionOperator.h>

template <class T>
class FermionOp
{
public:
    // typedefs

    typedef std::pair<FermionPair, T> FermionItem;
    typedef std::vector<FermionItem> FermionData;
    typedef std::map<std::string, T> FermionMap;

    // construction

    FermionOp();
    FermionOp(double value);
    FermionOp(const T& value);

    FermionOp(
        const std::string& key,
        const T& value
        );

    FermionOp(const FermionMap& map);
    FermionOp(FermionData&& fermion_data);
    FermionOp(const FermionData& fermion_data);
    FermionOp(FermionOp&& op);
    FermionOp(const FermionOp& op);

    // methods

    FermionOp& operator = (const FermionOp& op);
    FermionOp& operator = (FermionOp&& op);
    FermionOp normal_ordered();
    size_t getMaxIndex() const;
    bool isEmpty();
    std::string toString() const;
    void setErrorThreshold(double threshold);
    double error_threshold() const;
    FermionData data() const;
    FermionOp operator + (const FermionOp& rhs) const;
    FermionOp operator - (const FermionOp& rhs) const;
    FermionOp operator * (const FermionOp& rhs) const;
    FermionOp& operator += (const FermionOp& rhs);
    FermionOp& operator -= (const FermionOp& rhs);
    FermionOp& operator *= (const FermionOp& rhs);
};

Detailed Documentation

Fermion operator class.

Construction

FermionOp()

Constructor of FermionOp class.

Methods

FermionOp normal_ordered()

Compute and return the normal ordered form of a FermionOperator.

In our convention, normal ordering implies terms are ordered from highest tensor factor (on left) to lowest (on right). In addition: a^dagger comes before a

Returns:

FermionOp the normal ordered form of a FermionOperator

size_t getMaxIndex() const

get the max index

Returns:

size_t the max index

bool isEmpty()

Judge whether it is empty.

Returns:

bool if data is empty, return true, or else return false

std::string toString() const

data to string

Returns:

std::string convert data val to string

void setErrorThreshold(double threshold)

set error threshold

Parameters:

double

threshold val

double error_threshold() const

get error threshold

Returns:

double return the error threshold val

FermionData data() const

get data

Returns:

FermionData return fermion data

FermionOp operator + (const FermionOp& rhs) const

overload +

Returns:

FermionOp return (FermionOp_1 + FermionOp_2)

FermionOp operator - (const FermionOp& rhs) const

overload -

Returns:

FermionOp return (FermionOp_1 - FermionOp_2)

FermionOp operator * (const FermionOp& rhs) const

overload *

Returns:

FermionOp return (FermionOp_1 * FermionOp_2)

FermionOp& operator += (const FermionOp& rhs)

overload +=

Returns:

FermionOp & return (FermionOp_1 += FermionOp_2)

FermionOp& operator -= (const FermionOp& rhs)

overload -=

Returns:

FermionOp & return (FermionOp_1 -= FermionOp_2)

FermionOp& operator *= (const FermionOp& rhs)

overload *=

Returns:

FermionOp & return (FermionOp_1 *= FermionOp_2)

template class QPanda::PauliOp

Overview

Pauli operator class. More…

#include <PauliOperator.h>

template <class T>
class PauliOp
{
public:
    // typedefs

    typedef std::pair<QPauliPair, T> PauliItem;
    typedef std::vector<PauliItem> PauliData;
    typedef std::map<std::string, T> PauliMap;

    // construction

    PauliOp();
    PauliOp(const T& value);
    PauliOp(double value);

    PauliOp(
        const std::string& key,
        const T& value
        );

    PauliOp(const PauliMap& map);
    PauliOp(PauliOp&& op);
    PauliOp(const PauliOp& op);
    PauliOp(PauliData&& pauli);
    PauliOp(const PauliData& pauli);

    // methods

    PauliOp& operator = (const PauliOp& op);
    PauliOp& operator = (PauliOp&& op);
    PauliOp dagger() const;
    PauliOp remapQubitIndex(std::map<size_t, size_t>& index_map);
    size_t getMaxIndex();
    bool isEmpty();
    bool isAllPauliZorI();
    void setErrorThreshold(double threshold);
    double error_threshold() const;
    std::string toString() const;
    PauliData data() const;
    QHamiltonian toHamiltonian(bool* ok = nullptr) const;
    PauliOp operator + (const PauliOp& rhs) const;
    PauliOp operator - (const PauliOp& rhs) const;
    PauliOp operator * (const PauliOp& rhs) const;
    PauliOp& operator += (const PauliOp& rhs);
    PauliOp& operator -= (const PauliOp& rhs);
    PauliOp& operator *= (const PauliOp& rhs);
};

Detailed Documentation

Pauli operator class.

Construction

PauliOp()

Constructor of PauliOp class.

Methods

PauliOp dagger() const

get the Transposed conjugate matrix

Returns:

PauliOp return the Transposed conjugate matrix

PauliOp remapQubitIndex(std::map<size_t, size_t>& index_map)

remap qubit index

Parameters:

std::map<size_t
size_t>&	qubit index map

Returns:

PauliOp return remapped qubit index map

size_t getMaxIndex()

get the max index

Returns:

size_t the max index

bool isEmpty()

Judge whether it is empty.

Returns:

bool if data is empty, return true, or else return false

bool isAllPauliZorI()

Judge whether all of data is “Z”.

Returns:

bool if all data is “Z”, return true, or else return false

void setErrorThreshold(double threshold)

set error threshold

Parameters:

double

threshold val

double error_threshold() const

get error threshold

Returns:

double return the error threshold val

std::string toString() const

data to string

Returns:

std::string convert data val to string

PauliData data() const

get data

Returns:

PauliData return Pauli data

QHamiltonian toHamiltonian(bool* ok = nullptr) const

convert data to Hamiltonian

Parameters:

bool*

save the convert result, default is nullptr

Returns:

QHamiltonian the convert result

PauliOp operator + (const PauliOp& rhs) const

overload +

Returns:

PauliOp return (PauliOp_left + PauliOp_right)

PauliOp operator - (const PauliOp& rhs) const

overload -

Returns:

PauliOp return (PauliOp_left - PauliOp_right)

PauliOp operator * (const PauliOp& rhs) const

overload *

Returns:

PauliOp return (PauliOp_left * PauliOp_right)

PauliOp& operator += (const PauliOp& rhs)

overload +=

Returns:

PauliOp return (PauliOp_left += PauliOp_right)

PauliOp& operator -= (const PauliOp& rhs)

overload -=

Returns:

PauliOp return (PauliOp_left -= PauliOp_right)

PauliOp& operator *= (const PauliOp& rhs)

overload *=

Returns:

PauliOp return (PauliOp_left *= PauliOp_right)

// classes

template <class T>
class QPanda::FermionOp;

template <class T>
class QPanda::PauliOp;

Optimizer

class QPanda::AbstractOptimizer

Overview

Abstract Optimizer. More…

#include <AbstractOptimizer.h>

class AbstractOptimizer
{
public:
    // construction

    AbstractOptimizer();
    AbstractOptimizer(const AbstractOptimizer&);

    // methods

    AbstractOptimizer& operator = (const AbstractOptimizer&);
    virtual void registerFunc(const QOptFunc& func, const vector_d& optimized_para);
    virtual void setDisp(bool disp);
    virtual void setAdaptive(bool adaptive);
    virtual void setXatol(double xatol);
    virtual void setFatol(double fatol);
    virtual void setMaxFCalls(size_t max_fcalls);
    virtual void setMaxIter(size_t max_iter);
    virtual void setRestoreFromCacheFile(bool restore);
    virtual void setCacheFile(const std::string& cache_file);
    virtual void setTestValueAndParaFile(double test_value, const std::string& filename);
    virtual void exec() = 0;
    virtual QOptimizationResult getResult();
};

// direct descendants

class OriginCOBYLA;
class OriginLBFGSB;
class OriginNelderMead;
class OriginPowell;
class OriginSLSQP;

Detailed Documentation

Abstract Optimizer.

Construction

AbstractOptimizer()

Constructor of AbstractOptimizer class.

Methods

virtual void registerFunc(const QOptFunc& func, const vector_d& optimized_para)

register a user defined function and set some Optimizer parameters

Parameters:

QFunc&	user defined function
vector_d&	Optimizer parameters

virtual void setDisp(bool disp)

whether or not display the log info

Parameters:

bool

virtual void setAdaptive(bool adaptive)

whether or not use Para of Nelder-Mead

Parameters:

bool

virtual void setXatol(double xatol)

set absolute error in xopt between iterations that is acceptable for convergence

Parameters:

double

virtual void setFatol(double fatol)

set Absolute error in func(xopt) between iterations that is acceptable for convergence

Parameters:

double

virtual void setMaxFCalls(size_t max_fcalls)

set the max call times

Parameters:

size_t

virtual void setMaxIter(size_t max_iter)

set the max iter times

Parameters:

size_t

virtual void setRestoreFromCacheFile(bool restore)

set whether or not restore from cache file

Parameters:

bool

virtual void setCacheFile(const std::string& cache_file)

set cache file

Parameters:

std::string&

cache file name

virtual void setTestValueAndParaFile(
    double test_value,
    const std::string& filename
    )

only for test

Parameters:

double	test value
std::string&	file name

virtual void exec() = 0

execute optimization

virtual QOptimizationResult getResult()

get optimization result

Returns:

QOptimizationResult optimization result

class QPanda::Brent

Overview

Given a function of one-variable, return the local minimum of the function isolated to a fractional precision of tol. More…

#include <OriginPowell.h>

class Brent
{
public:
    // construction

    Brent(const Func& func, double tol = 1.48e-8, size_t maxiter = 500);
    Brent(const Brent&);

    // methods

    Brent& operator = (const Brent&);
    void optimize();
    std::pair<double, QResultPair> getResult();
};

Detailed Documentation

Given a function of one-variable, return the local minimum of the function isolated to a fractional precision of tol.

Uses inverse parabolic interpolation when possible to speed up convergence of golden section method.

Construction

Brent(const Func& func, double tol = 1.48e-8, size_t maxiter = 500)

Constructor of Brent.

Methods

void optimize()

execute optimization

std::pair<double, QResultPair> getResult()

get result

Returns:

std::pair<double, QResultPair> result

class QPanda::OptimizerFactory

Overview

Class of Optimizer factory. More…

#include <OptimizerFactory.h>

class OptimizerFactory
{
public:
    // methods

    static std::unique_ptr<AbstractOptimizer> makeOptimizer(const OptimizerType& optimizer);
    static std::unique_ptr<AbstractOptimizer> makeOptimizer(const std::string& optimizer);
};

Detailed Documentation

Class of Optimizer factory.

Methods

static std::unique_ptr<AbstractOptimizer> makeOptimizer(const OptimizerType& optimizer)

create a Optimizer object by OptimizerType

Parameters:

OptimizerType

Optimizer Type

Returns:

std::unique_ptr<AbstractOptimizer>

static std::unique_ptr<AbstractOptimizer> makeOptimizer(const std::string& optimizer)

create a Optimizer object by OptimizerType string

Parameters:

std::string&

Optimizer Type string

Returns:

std::unique_ptr<AbstractOptimizer>

class QPanda::OriginCOBYLA

Overview

Minimization of scalar function of one or more variables using the COBYLA algorithm. More…

#include <OriginCOBYLA.h>

class OriginCOBYLA: public QPanda::AbstractOptimizer
{
public:
    // construction

    OriginCOBYLA();
    OriginCOBYLA(const OriginCOBYLA&);

    // methods

    OriginCOBYLA& operator = (const OriginCOBYLA&);
    virtual void exec();

    void set_lower_and_upper_bounds(
        vector_d& lower_bound,
        vector_d& upper
        );

    void add_equality_constraint(QOptFunc func);
    void add_inequality_constraint(QOptFunc func);
};

Inherited Members

public:
    // methods

    AbstractOptimizer& operator = (const AbstractOptimizer&);
    virtual void registerFunc(const QOptFunc& func, const vector_d& optimized_para);
    virtual void setDisp(bool disp);
    virtual void setAdaptive(bool adaptive);
    virtual void setXatol(double xatol);
    virtual void setFatol(double fatol);
    virtual void setMaxFCalls(size_t max_fcalls);
    virtual void setMaxIter(size_t max_iter);
    virtual void setRestoreFromCacheFile(bool restore);
    virtual void setCacheFile(const std::string& cache_file);
    virtual void setTestValueAndParaFile(double test_value, const std::string& filename);
    virtual void exec() = 0;
    virtual QOptimizationResult getResult();

Detailed Documentation

Minimization of scalar function of one or more variables using the COBYLA algorithm.

Construction

OriginCOBYLA()

Constructor of OriginCOBYLA.

Methods

virtual void exec()

execute optimization

class QPanda::OriginLBFGSB

Overview

Minimization of scalar function of one or more variables using the COBYLA algorithm. More…

#include <OriginLBFGSB.h>

class OriginLBFGSB: public QPanda::AbstractOptimizer
{
public:
    // construction

    OriginLBFGSB();
    OriginLBFGSB(const OriginLBFGSB&);

    // methods

    OriginLBFGSB& operator = (const OriginLBFGSB&);
    virtual void exec();

    void set_lower_and_upper_bounds(
        vector_d& lower_bound,
        vector_d& upper
        );

    void add_equality_constraint(QOptFunc func);
    void add_inequality_constraint(QOptFunc func);
};

Inherited Members

public:
    // methods

    AbstractOptimizer& operator = (const AbstractOptimizer&);
    virtual void registerFunc(const QOptFunc& func, const vector_d& optimized_para);
    virtual void setDisp(bool disp);
    virtual void setAdaptive(bool adaptive);
    virtual void setXatol(double xatol);
    virtual void setFatol(double fatol);
    virtual void setMaxFCalls(size_t max_fcalls);
    virtual void setMaxIter(size_t max_iter);
    virtual void setRestoreFromCacheFile(bool restore);
    virtual void setCacheFile(const std::string& cache_file);
    virtual void setTestValueAndParaFile(double test_value, const std::string& filename);
    virtual void exec() = 0;
    virtual QOptimizationResult getResult();

Detailed Documentation

Minimization of scalar function of one or more variables using the COBYLA algorithm.

Construction

OriginLBFGSB()

Constructor of OriginLBFGSB.

Methods

virtual void exec()

execute optimization

class QPanda::OriginNelderMead

Overview

Minimization of scalar function of one or more variables using the Nelder-Mead algorithm. More…

#include <OriginNelderMead.h>

class OriginNelderMead: public QPanda::AbstractOptimizer
{
public:
    // construction

    OriginNelderMead();
    OriginNelderMead(const OriginNelderMead&);

    // methods

    OriginNelderMead& operator = (const OriginNelderMead&);
    virtual void exec();
    virtual QOptimizationResult getResult();
};

Inherited Members

public:
    // methods

    AbstractOptimizer& operator = (const AbstractOptimizer&);
    virtual void registerFunc(const QOptFunc& func, const vector_d& optimized_para);
    virtual void setDisp(bool disp);
    virtual void setAdaptive(bool adaptive);
    virtual void setXatol(double xatol);
    virtual void setFatol(double fatol);
    virtual void setMaxFCalls(size_t max_fcalls);
    virtual void setMaxIter(size_t max_iter);
    virtual void setRestoreFromCacheFile(bool restore);
    virtual void setCacheFile(const std::string& cache_file);
    virtual void setTestValueAndParaFile(double test_value, const std::string& filename);
    virtual void exec() = 0;
    virtual QOptimizationResult getResult();

Detailed Documentation

Minimization of scalar function of one or more variables using the Nelder-Mead algorithm.

Construction

OriginNelderMead()

Constructor of OriginNelderMead.

Methods

virtual void exec()

execute optimization

virtual QOptimizationResult getResult()

get optimization result

Returns:

QOptimizationResult optimization result

class QPanda::OriginPowell

Overview

Minimization of scalar function of one or more variables using the Powell algorithm. More…

#include <OriginPowell.h>

class OriginPowell: public QPanda::AbstractOptimizer
{
public:
    // construction

    OriginPowell();
    OriginPowell(const OriginPowell&);

    // methods

    OriginPowell& operator = (const OriginPowell&);
    virtual void exec();
    virtual QOptimizationResult getResult();
};

Inherited Members

public:
    // methods

    AbstractOptimizer& operator = (const AbstractOptimizer&);
    virtual void registerFunc(const QOptFunc& func, const vector_d& optimized_para);
    virtual void setDisp(bool disp);
    virtual void setAdaptive(bool adaptive);
    virtual void setXatol(double xatol);
    virtual void setFatol(double fatol);
    virtual void setMaxFCalls(size_t max_fcalls);
    virtual void setMaxIter(size_t max_iter);
    virtual void setRestoreFromCacheFile(bool restore);
    virtual void setCacheFile(const std::string& cache_file);
    virtual void setTestValueAndParaFile(double test_value, const std::string& filename);
    virtual void exec() = 0;
    virtual QOptimizationResult getResult();

Detailed Documentation

Minimization of scalar function of one or more variables using the Powell algorithm.

Construction

OriginPowell()

Constructor of OriginPowell.

Methods

virtual void exec()

execute optimization

virtual QOptimizationResult getResult()

get optimization result

Returns:

QOptimizationResult optimization result

class QPanda::OriginSLSQP

Overview

Minimization of scalar function of one or more variables using the COBYLA algorithm. More…

#include <OriginSLSQP.h>

class OriginSLSQP: public QPanda::AbstractOptimizer
{
public:
    // construction

    OriginSLSQP();
    OriginSLSQP(const OriginSLSQP&);

    // methods

    OriginSLSQP& operator = (const OriginSLSQP&);
    virtual void exec();

    void set_lower_and_upper_bounds(
        vector_d& lower_bound,
        vector_d& upper
        );

    void add_equality_constraint(QOptFunc func);
    void add_inequality_constraint(QOptFunc func);
};

Inherited Members

public:
    // methods

    AbstractOptimizer& operator = (const AbstractOptimizer&);
    virtual void registerFunc(const QOptFunc& func, const vector_d& optimized_para);
    virtual void setDisp(bool disp);
    virtual void setAdaptive(bool adaptive);
    virtual void setXatol(double xatol);
    virtual void setFatol(double fatol);
    virtual void setMaxFCalls(size_t max_fcalls);
    virtual void setMaxIter(size_t max_iter);
    virtual void setRestoreFromCacheFile(bool restore);
    virtual void setCacheFile(const std::string& cache_file);
    virtual void setTestValueAndParaFile(double test_value, const std::string& filename);
    virtual void exec() = 0;
    virtual QOptimizationResult getResult();

Detailed Documentation

Minimization of scalar function of one or more variables using the COBYLA algorithm.

Construction

OriginSLSQP()

Constructor of OriginSLSQP.

Methods

virtual void exec()

execute optimization

// classes

class QPanda::AbstractOptimizer;
class QPanda::Brent;
class QPanda::OptimizerFactory;
class QPanda::OriginCOBYLA;
class QPanda::OriginLBFGSB;
class QPanda::OriginNelderMead;
class QPanda::OriginPowell;
class QPanda::OriginSLSQP;

Utils

class QPanda::RJson

Overview

a wrapper class of rapidjson. More…

#include <RJson.h>

class RJson
{
public:
    // methods

    static int GetValue(
        const rapidjson::Value** value,
        const char* name,
        const rapidjson::Value* parent
        );

    static int GetValue(
        const rapidjson::Value** value,
        const size_t idx,
        const rapidjson::Value* parent
        );

    template <typename T>
    static int GetObject(
        const rapidjson::Value** value,
        T tag,
        const rapidjson::Value* parent
        );

    template <typename T>
    static int GetArray(
        const rapidjson::Value** value,
        T tag,
        const rapidjson::Value* parent
        );

    template <typename T>
    static int GetStr(
        std::string& str,
        T tag,
        const rapidjson::Value* parent
        );

    template <typename T>
    static int GetBool(
        bool& n,
        T tag,
        const rapidjson::Value* parent
        );

    template <typename T>
    static int GetInt(int& n, T tag, const rapidjson::Value* parent);

    template <typename T>
    static int GetDouble(
        double& n,
        T tag,
        const rapidjson::Value* parent
        );

    template <typename T1, typename T2>
    static int GetValue(
        const rapidjson::Value** value,
        T1 t1,
        T2 t2,
        const rapidjson::Value* parent
        );

    template <typename T1, typename T2>
    static int GetObject(
        const rapidjson::Value** value,
        T1 t1,
        T2 t2,
        const rapidjson::Value* parent
        );

    template <typename T1, typename T2>
    static int GetArray(
        const rapidjson::Value** value,
        T1 t1,
        T2 t2,
        const rapidjson::Value* parent
        );

    template <typename T1, typename T2>
    static int GetStr(
        std::string& str,
        T1 t1,
        T2 t2,
        const rapidjson::Value* parent
        );

    template <typename T1, typename T2>
    static int GetBool(
        bool& n,
        T1 t1,
        T2 t2,
        const rapidjson::Value* parent
        );

    template <typename T1, typename T2>
    static int GetInt(
        int& n,
        T1 t1,
        T2 t2,
        const rapidjson::Value* parent
        );

    template <typename T1, typename T2>
    static int GetDouble(
        double& n,
        T1 t1,
        T2 t2,
        const rapidjson::Value* parent
        );

    static int ToString(std::string& str, const rapidjson::Value* node);
    static std::string ToString(const rapidjson::Value* node);
    static bool parse(const std::string& filename, rapidjson::Document& doc);

    static bool validate(
        const std::string& filename,
        const std::string& config_schema,
        rapidjson::Document& doc
        );
};

Detailed Documentation

a wrapper class of rapidjson.

Methods

static int GetValue(
    const rapidjson::Value** value,
    const char* name,
    const rapidjson::Value* parent
    )

get the val by the name of a key

Parameters:

rapidjson::Value**	Pointer of a pointer, pointer to the storage Memory address.
char*	the name of key
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

static int GetValue(
    const rapidjson::Value** value,
    const size_t idx,
    const rapidjson::Value* parent
    )

get the val by index

Parameters:

rapidjson::Value**	Pointer of a pointer, pointer to the storage Memory address.
size_t	the target index
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T>
static int GetObject(
    const rapidjson::Value** value,
    T tag,
    const rapidjson::Value* parent
    )

get the object by tag

Parameters:

rapidjson::Value**	Pointer of a pointer, pointer to the storage Memory address.
T	tag
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T>
static int GetArray(
    const rapidjson::Value** value,
    T tag,
    const rapidjson::Value* parent
    )

get the array by tag

Parameters:

rapidjson::Value**	Pointer of a pointer, pointer to the storage Memory address.
T	tag
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T>
static int GetStr(
    std::string& str,
    T tag,
    const rapidjson::Value* parent
    )

get the string of tag

Parameters:

std::string&	the string of tag
T	tag
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T>
static int GetBool(
    bool& n,
    T tag,
    const rapidjson::Value* parent
    )

get the bool val of tag

Parameters:

bool&	the bool val
T	tag
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T>
static int GetInt(
    int& n,
    T tag,
    const rapidjson::Value* parent
    )

get the int val of tag

Parameters:

int&	the int val
T	tag
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T>
static int GetDouble(
    double& n,
    T tag,
    const rapidjson::Value* parent
    )

get the double val of tag

Parameters:

double&	the double val
T	tag
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T1, typename T2>
static int GetValue(
    const rapidjson::Value** value,
    T1 t1,
    T2 t2,
    const rapidjson::Value* parent
    )

get the val of t1.t2

Parameters:

rapidjson::Value**	Pointer of a pointer, pointer to the storage Memory address.
T1	t1
T2	t2
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T1, typename T2>
static int GetObject(
    const rapidjson::Value** value,
    T1 t1,
    T2 t2,
    const rapidjson::Value* parent
    )

get the object pointer of t1.t2

Parameters:

rapidjson::Value**	Pointer of a pointer, pointer to the storage Memory address.
T1	t1
T2	t2
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T1, typename T2>
static int GetArray(
    const rapidjson::Value** value,
    T1 t1,
    T2 t2,
    const rapidjson::Value* parent
    )

get the Array pointer of t1.t2

Parameters:

rapidjson::Value**	Pointer of a pointer, pointer to the storage Memory address.
T1	t1
T2	t2
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T1, typename T2>
static int GetStr(
    std::string& str,
    T1 t1,
    T2 t2,
    const rapidjson::Value* parent
    )

get the string of t1.t2

Parameters:

std::string&	the target string
T1	t1
T2	t2
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T1, typename T2>
static int GetBool(
    bool& n,
    T1 t1,
    T2 t2,
    const rapidjson::Value* parent
    )

get the bool val of t1.t2

Parameters:

bool&	the target bool val
T1	t1
T2	t2
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T1, typename T2>
static int GetInt(
    int& n,
    T1 t1,
    T2 t2,
    const rapidjson::Value* parent
    )

get the int val of t1.t2

Parameters:

int&	the target int val
T1	t1
T2	t2
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

template <typename T1, typename T2>
static int GetDouble(
    double& n,
    T1 t1,
    T2 t2,
    const rapidjson::Value* parent
    )

get the double val of t1.t2

Parameters:

double&	the target double val
T1	t1
T2	t2
rapidjson::Value*	parent node pointer

Returns:

int 0: on success, -1: others

static int ToString(std::string& str, const rapidjson::Value* node)

node data to string

Parameters:

std::string&	the string of node data
rapidjson::Value*	the target node

Returns:

int 0: on success, -1: others

static std::string ToString(const rapidjson::Value* node)

node data to string

Parameters:

rapidjson::Value*

the target node

Returns:

std::string the string of node data. if any error occurred, the returned string is empty.

static bool parse(const std::string& filename, rapidjson::Document& doc)

parse a faile

Parameters:

std::string&	the target file name
rapidjson::Document&	JSON file parser

Returns:

bool return true on success, or else false on any error occurred

static bool validate(
    const std::string& filename,
    const std::string& config_schema,
    rapidjson::Document& doc
    )

judge the file whether valid or not.

Parameters:

std::string&	the target file name
std::string&	the config schema
rapidjson::Document&	JSON file parser

Returns:

bool if file is valid return true, or else return false

// classes

class QPanda::RJson;

class QPanda::NodeSortProblemGenerator

Overview

Node Sort Problem Generator. More…

#include <NodeSortProblemGenerator.h>

class NodeSortProblemGenerator
{
public:
    // methods

    void setProblemGraph(const std::vector<std::vector<double>>& graph);
    void setLambda1(double lambda);
    void setLambda2(double lambda);
    void setLambda3(double lambda);
    void setArbitaryCofficient(double arbitary_cofficient);
    void exec();
    PauliOperator getHamiltonian() const;
    std::vector<AnsatzGate> getAnsatz() const;
    Eigen::VectorXd getLinearSolverResult() const;
    Eigen::MatrixXd getMatrixA() const;
    Eigen::VectorXd getVectorB() const;
};

Detailed Documentation

Node Sort Problem Generator.

Methods

void setProblemGraph(const std::vector<std::vector<double>>& graph)

Set problem graph.

Parameters:

const

std::vector<std::vector<double>>& problem graph

void setLambda1(double lambda)

Set model parameter lamda1.

Parameters:

double

lambda

void setLambda2(double lambda)

Set model parameter lamda2.

Parameters:

double

lambda

void setLambda3(double lambda)

Set model parameter lamda3.

Parameters:

double

lambda

void setArbitaryCofficient(double arbitary_cofficient)

Set arbitary cofficient.

Parameters:

double

arbitary cofficient

void exec()

Execute.

PauliOperator getHamiltonian() const

Get hamiltonian from the problem model.

Returns:

PauliOperator hamiltonian

See also:

PauliOperator

std::vector<AnsatzGate> getAnsatz() const

Get ansatz from the problem model.

Returns:

std::vector<QITE::AnsatzGate> ansatz

See also:

AnsatzGate

Eigen::VectorXd getLinearSolverResult() const

Get linear solver result of the problem model.

Returns:

Eigen::VectorXd linear solver result

See also:

AnsatzGate

Eigen::MatrixXd getMatrixA() const

Get the coefficient matrix.

Returns:

Eigen::MatrixXd parameters of Matirx

See also:

AnsatzGate

Eigen::VectorXd getVectorB() const

Get the constent term.

Returns:

Eigen::VectorXd constent term

See also:

AnsatzGate

QPanda2 Components Group.

ChemiQ

HamiltonianSimulation

MaxCutProblemGenerator

Operator

Optimizer

Utils

// classes

class QPanda::NodeSortProblemGenerator;

Core

QuantumCircuit

class QGATE_SPACE::AbstractAngleParameter

Quantum gate angle parameter basic abstract class.

#include <QuantumGate.h>

class AbstractAngleParameter
{
public:
    // methods

    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
};

// direct descendants

class CU;
class U4;

class QPanda::AbstractClassicalProg

Overview

Classical program abstract class. More…

#include <ClassicalProgram.h>

class AbstractClassicalProg
{
public:
    // methods

    virtual std::shared_ptr<CExpr> getExpr() = 0;
    virtual cbit_size_t get_val() = 0;
};

// direct descendants

class ClassicalProg;
class OriginClassicalProg;

Detailed Documentation

Classical program abstract class.

Methods

virtual std::shared_ptr<CExpr> getExpr() = 0

Get classical expr shared ptr.

Returns:

std::shared_ptr<CExpr>

virtual cbit_size_t get_val() = 0

Get classical program value.

Returns:

cbit_size_t

class QPanda::AbstractControlFlowNode

Overview

Superclass for QIfProg/QWhileProg. More…

#include <ControlFlow.h>

class AbstractControlFlowNode
{
public:
    // methods

    virtual std::shared_ptr<QNode> getTrueBranch() const = 0;
    virtual std::shared_ptr<QNode> getFalseBranch() const = 0;
    virtual void setTrueBranch(QProg node) = 0;
    virtual void setFalseBranch(QProg node) = 0;
    virtual ClassicalCondition getCExpr() = 0;
};

// direct descendants

class OriginQIf;
class OriginQWhile;
class QIfProg;
class QWhileProg;

Detailed Documentation

Superclass for QIfProg/QWhileProg.

Methods

virtual std::shared_ptr<QNode> getTrueBranch() const = 0

Get true branch.

Returns:

std::shared_ptr<QNode>

virtual std::shared_ptr<QNode> getFalseBranch() const = 0

Get false branch.

Returns:

std::shared_ptr<QNode>

virtual void setTrueBranch(QProg node) = 0

Set the True branch.

Parameters:

Node	True branch node

virtual void setFalseBranch(QProg node) = 0

Set the False Branch object.

Parameters:

Node	False branch node

virtual ClassicalCondition getCExpr() = 0

Get classical expr.

Returns:

ClassicalCondition ptr

class QPanda::AbstractNodeManager

Overview

Quantum node manager basic abstract class. More…

#include <QNode.h>

class AbstractNodeManager
{
public:
    // methods

    virtual NodeIter getFirstNodeIter() = 0;
    virtual NodeIter getLastNodeIter() = 0;
    virtual NodeIter getEndNodeIter() = 0;
    virtual NodeIter getHeadNodeIter() = 0;
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>) = 0;
    virtual NodeIter deleteQNode(NodeIter&) = 0;
    virtual void pushBackNode(std::shared_ptr<QNode>) = 0;
};

// direct descendants

class AbstractQuantumCircuit;
class AbstractQuantumProgram;

Detailed Documentation

Quantum node manager basic abstract class.

Methods

virtual NodeIter getFirstNodeIter() = 0

Get the first NodeIter.

Returns:

NodeIter

virtual NodeIter getLastNodeIter() = 0

Get the last NodeIter.

Returns:

NodeIter

virtual NodeIter getEndNodeIter() = 0

Get the end NodeIter.

Returns:

NodeIter

virtual NodeIter getHeadNodeIter() = 0

Get the head NodeIter.

Returns:

NodeIter

virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>) = 0

Insert a new QNode at the location specified by NodeIter.

Parameters:

NodeIter&	specified location
std::shared_ptr<QNode>	Inserted QNode

Returns:

NodeIter

virtual NodeIter deleteQNode(NodeIter&) = 0

Delete a QNode at the location specified by NodeIter.

Parameters:

NodeIter&

specified location

Returns:

NodeIter Deleted NodeIter

virtual void pushBackNode(std::shared_ptr<QNode>) = 0

Insert a new Node at the end of current quantum circuit.

Parameters:

QNode*

quantum node

Returns:

void

See also:

QNode

class QPanda::AbstractQGateNode

Overview

Quantum gate basic abstract class. More…

#include <QGate.h>

class AbstractQGateNode
{
public:
    // methods

    virtual size_t getQuBitVector(QVec&) const = 0;
    virtual Qubit* popBackQuBit() = 0;
    virtual void PushBackQuBit(Qubit*) = 0;
    virtual size_t getTargetQubitNum() const = 0;
    virtual size_t getControlQubitNum() const = 0;
    virtual QuantumGate* getQGate() const = 0;
    virtual void setQGate(QuantumGate*) = 0;
    virtual bool isDagger() const = 0;
    virtual size_t getControlVector(QVec&) const = 0;
    virtual void clear_control() = 0;
    virtual bool setDagger(bool) = 0;
    virtual bool setControl(QVec) = 0;
    virtual void remap(QVec) = 0;
};

// direct descendants

class OriginQGate;
class QGate;

Detailed Documentation

Quantum gate basic abstract class.

Methods

virtual size_t getQuBitVector(QVec&) const = 0

Get qubit vector inside this quantum gate.

Parameters:

QVec&

qubit vector

Returns:

size_t

See also:

GateType

virtual Qubit* popBackQuBit() = 0

erase qubit vector element at end

Returns:

Qubit*

virtual void PushBackQuBit(Qubit*) = 0

insert qubit vector element at end

Parameters:

Qubit*

Qubit pointer

virtual size_t getTargetQubitNum() const = 0

Get target qubit num inside this quantum gate.

Returns:

size_t qubit num

virtual size_t getControlQubitNum() const = 0

Get control qubit num inside this quantum gate.

Returns:

size_t qubit num

virtual QuantumGate* getQGate() const = 0

Get Quantum Gate.

Returns:

QuantumGate *

virtual void setQGate(QuantumGate*) = 0

Set Quantum Gate.

Parameters:

QuantumGate*

QuantumGate pointer

virtual bool isDagger() const = 0

Judge current quantum gate is dagger.

Returns:

bool

virtual size_t getControlVector(QVec&) const = 0

Get control vector fron current quantum gate node.

Parameters:

QVec&

qubits vector

Returns:

size_t

See also:

QVec

virtual void clear_control() = 0

Clear the control qubits for current quantum gate.

See also:

QVec

virtual bool setDagger(bool) = 0

Set dagger to current quantum gate.

Parameters:

bool

is dagger

Returns:

bool

virtual bool setControl(QVec) = 0

Set control qubits to current quantum gate.

Parameters:

QVec	control qubits vector

Returns:

bool

See also:

QVec

virtual void remap(QVec) = 0

remap qubit

Returns:

class QPanda::AbstractQuantumCircuit

Overview

Quantum circuit basic abstract class. More…

#include <QCircuit.h>

class AbstractQuantumCircuit: public QPanda::AbstractNodeManager
{
public:
    // methods

    virtual bool isDagger() const = 0;
    virtual bool getControlVector(QVec&) = 0;
    virtual void setDagger(bool isDagger) = 0;
    virtual void setControl(QVec) = 0;
    virtual void clearControl() = 0;
    virtual size_t get_used_qubits(QVec&) const = 0;
    virtual size_t get_qgate_num() = 0;
};

// direct descendants

class OriginCircuit;
class QCircuit;

Inherited Members

public:
    // methods

    virtual NodeIter getFirstNodeIter() = 0;
    virtual NodeIter getLastNodeIter() = 0;
    virtual NodeIter getEndNodeIter() = 0;
    virtual NodeIter getHeadNodeIter() = 0;
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>) = 0;
    virtual NodeIter deleteQNode(NodeIter&) = 0;
    virtual void pushBackNode(std::shared_ptr<QNode>) = 0;

Detailed Documentation

Quantum circuit basic abstract class.

Methods

virtual bool isDagger() const = 0

Judge current quantum circuit is dagger.

Returns:

bool

virtual bool getControlVector(QVec&) = 0

Get control vector fron current quantum circuit node.

Parameters:

QVec&

qubits vector

Returns:

bool

See also:

QVec

virtual void setDagger(bool isDagger) = 0

Set dagger to current quantum circuit.

Parameters:

bool

is dagger

virtual void setControl(QVec) = 0

Set control qubits to current quantum circuit.

Parameters:

QVec	control qubits vector

See also:

QVec

virtual void clearControl() = 0

Clear the control qubits for current quantum circuit.

See also:

QVec

virtual size_t get_used_qubits(QVec&) const = 0

Get the used qubits for current quantum circuit.

Parameters:

QVec	used qubits vector

Returns:

size_t

virtual size_t get_qgate_num() = 0

Get current quantum circuit qgate number.

Returns:

size_t

class QPanda::AbstractQuantumMeasure

Overview

Quantum Measure basic abstract class. More…

#include <QuantumMeasure.h>

class AbstractQuantumMeasure
{
public:
    // methods

    virtual Qubit* getQuBit() const = 0;
    virtual CBit* getCBit() const = 0;
};

// direct descendants

class OriginMeasure;
class QMeasure;

Detailed Documentation

Quantum Measure basic abstract class.

Methods

virtual Qubit* getQuBit() const = 0

Get measure node qubit address.

Returns:

Qubit *

virtual CBit* getCBit() const = 0

Get measure node cbit address.

Returns:

CBit *

class QPanda::AbstractQuantumProgram

Overview

Quantum program basic abstract class. More…

#include <QProgram.h>

class AbstractQuantumProgram: public QPanda::AbstractNodeManager
{
public:
    // methods

    virtual void clear() = 0;
    virtual size_t get_max_qubit_addr() = 0;
    virtual size_t get_used_qubits(QVec&) = 0;
    virtual size_t get_used_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t get_qgate_num() = 0;
    virtual bool is_measure_last_pos() = 0;
    virtual std::map<Qubit*, bool> get_measure_pos() = 0;
    virtual std::vector<std::pair<Qubit*, ClassicalCondition>> get_measure_qubits_cbits() = 0;
};

// direct descendants

class OriginProgram;
class QProg;

Inherited Members

public:
    // methods

    virtual NodeIter getFirstNodeIter() = 0;
    virtual NodeIter getLastNodeIter() = 0;
    virtual NodeIter getEndNodeIter() = 0;
    virtual NodeIter getHeadNodeIter() = 0;
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>) = 0;
    virtual NodeIter deleteQNode(NodeIter&) = 0;
    virtual void pushBackNode(std::shared_ptr<QNode>) = 0;

Detailed Documentation

Quantum program basic abstract class.

Methods

virtual void clear() = 0

Clear all node in current quantum program node.

virtual size_t get_max_qubit_addr() = 0

Gets the maximum physical address of used qubits.

Returns:

size_t maximum physical address

virtual size_t get_used_qubits(QVec&) = 0

Get the used qubits for current quantum program.

Parameters:

QVec	used qubits vector

Returns:

size_t

virtual size_t get_used_cbits(std::vector<ClassicalCondition>&) = 0

Get the used classical bits for current quantum program.

Parameters:

QVec	used qubits vector

Returns:

size_t

virtual size_t get_qgate_num() = 0

Get current quantum program qgate number.

Returns:

size_t

virtual bool is_measure_last_pos() = 0

Measure operation in the last position of the program.

Returns:

bool

virtual std::map<Qubit*, bool> get_measure_pos() = 0

Get Measure operation position of the program.

Returns:

std::map<Qubit*, bool>

virtual std::vector<std::pair<Qubit*, ClassicalCondition>> get_measure_qubits_cbits() = 0

Get Measure operation qubits and cbits vector.

Returns:

std::vector<std::pair<Qubit*, ClassicalCondition>>

class QPanda::AbstractQuantumReset

Overview

Quantum Reset basic abstract class. More…

#include <QReset.h>

class AbstractQuantumReset
{
public:
    // methods

    virtual Qubit* getQuBit() const = 0;
};

// direct descendants

class OriginReset;
class QReset;

Detailed Documentation

Quantum Reset basic abstract class.

Methods

virtual Qubit* getQuBit() const = 0

Get the reset qubit.

Returns:

Qubit *

class QPanda::CExpr

Overview

classical expression base class More…

#include <CExprFactory.h>

class CExpr
{
public:
    // methods

    virtual CExpr* getLeftExpr() const = 0;
    virtual CExpr* getRightExpr() const = 0;
    virtual void setLeftExpr(CExpr* left_expr) = 0;
    virtual void setRightExpr(CExpr* right_expr) = 0;
    virtual std::string getName() const = 0;
    virtual CBit* getCBit() const = 0;
    virtual bool checkValidity() const = 0;
    virtual cbit_size_t get_val() const = 0;
    virtual int getContentSpecifier() const = 0;
    virtual CExpr* deepcopy() const = 0;
    virtual void getCBitsName(std::vector<std::string>&) = 0;
};

// direct descendants

class OriginCExpr;

Detailed Documentation

classical expression base class

Methods

virtual CExpr* getLeftExpr() const = 0

Get the Left Expr pointer.

Returns:

CExpr*

virtual CExpr* getRightExpr() const = 0

Get the Right Expr pointer.

Returns:

CExpr*

virtual void setLeftExpr(CExpr* left_expr) = 0

Set the Left Expr pointer.

Parameters:

CExpr*

left expr

virtual void setRightExpr(CExpr* right_expr) = 0

Set the Right Expr pointer.

Parameters:

CExpr*

right expr

virtual std::string getName() const = 0

Get the Name object.

Returns:

std::string

virtual CBit* getCBit() const = 0

get classical bit pointer

Returns:

CBit*

virtual bool checkValidity() const = 0

check validity

Returns:

true check validity ture

false check validity false

virtual cbit_size_t get_val() const = 0

get value

Returns:

cbit_size_t

virtual int getContentSpecifier() const = 0

get specifier of this cexpr

Returns:

int

virtual CExpr* deepcopy() const = 0

deep copy this cexpr

Returns:

CExpr*

virtual void getCBitsName(std::vector<std::string>&) = 0

get all cbits name

Parameters:

std::vector<std::string>

cibts name vector

class QPanda::CExprFactory

Overview

classical expr class factory More…

#include <CExprFactory.h>

class CExprFactory
{
public:
    // typedefs

    typedef std::function<CExpr*(CBit*)> cbit_constructor_t;
    typedef std::map<std::string, cbit_constructor_t> cbit_constructor_map_t;
    typedef std::function<CExpr*(cbit_size_t)> value_constructor_t;
    typedef std::map<std::string, value_constructor_t> value_constructor_map_t;
    typedef std::function<CExpr*(CExpr*, CExpr*, int)> operator_constructor_t;
    typedef std::map<std::string, operator_constructor_t> operator_constructor_map_t;

    // fields

    cbit_constructor_map_t _CExpr_CBit_Constructor;
    value_constructor_map_t _CExpr_Value_Constructor;
    operator_constructor_map_t _CExpr_Operator_Constructor;

    // methods

    static CExprFactory& GetFactoryInstance();
    CExpr* GetCExprByCBit(CBit* cbit);
    void registerclass_CBit_(std::string& name, cbit_constructor_t constructor);
    CExpr* GetCExprByValue(cbit_size_t value);
    void registerclass_Value_(std::string&, value_constructor_t);
    CExpr* GetCExprByOperation(CExpr* left_cexpr, CExpr* right_cexpr, int operat);
    void registerclass_operator_ (std::string&, operator_constructor_t);
};

Detailed Documentation

classical expr class factory

Typedefs

typedef std::function<CExpr*(CBit*)> cbit_constructor_t

We typedef the cbit_constructor_t is a constructor that use cbit create cexpr.

typedef std::map<std::string, cbit_constructor_t> cbit_constructor_map_t

We typedef the cbit_constructor_map_t is a collection of constructors that use cbit create cexpr.

typedef std::function<CExpr*(cbit_size_t)> value_constructor_t

We typedef the value_constructor_t is a constructor that use value create cexpr.

typedef std::map<std::string, value_constructor_t> value_constructor_map_t

We typedef the value_constructor_map_t is a collection of constructors that use value create cexpr.

typedef std::function<CExpr*(CExpr*, CExpr*, int)> operator_constructor_t

We typedef the operator_constructor_t is a constructor that use operator create cexpr.

typedef std::map<std::string, operator_constructor_t> operator_constructor_map_t

We typedef the operator_constructor_map_t is a collection of constructors that use operator create cexpr.

Fields

cbit_constructor_map_t _CExpr_CBit_Constructor

A collection of constructors that use cbit create cexpr.

value_constructor_map_t _CExpr_Value_Constructor

A collection of constructors that use value create cexpr.

operator_constructor_map_t _CExpr_Operator_Constructor

A collection of constructors that use operator create cexpr.

Methods

static CExprFactory& GetFactoryInstance()

Get the Factory Instance object.

Returns:

CExprFactory &

CExpr* GetCExprByCBit(CBit* cbit)

Get cexpr by cbit.

Parameters:

cbit	target cbit

Returns:

CExpr*

void registerclass_CBit_(std::string& name, cbit_constructor_t constructor)

Registration function This function can be used to register constructors that inherit subclasses of the CExpr class.

Parameters:

std::string	name subclass name
cbit_constructor_t	constructor subclass constructor

CExpr* GetCExprByValue(cbit_size_t value)

Get cexpr by value.

Parameters:

cbit_size_t

target value

Returns:

CExpr*

void registerclass_Value_(std::string&, value_constructor_t)

Registration function This function can be used to register constructors that inherit subclasses of the CExpr class.

Parameters:

std::string	subclass name
value_constructor_t	subclass constructor

CExpr* GetCExprByOperation(CExpr* left_cexpr, CExpr* right_cexpr, int operat)

Get cexpr by Operation.

Parameters:

CExpr*	left CExpr
CExpr*	right CExpr
int	target operator

Returns:

CExpr*

void registerclass_operator_ (std::string&, operator_constructor_t)

Registration function This function can be used to register constructors that inherit subclasses of the CExpr class.

Parameters:

std::string	subclass name
operator_constructor_t	subclass constructor

class QPanda::CExprFactoryHelper

Overview

CExpr factory helper Provide CExprFactory class registration interface for the outside. More…

#include <CExprFactory.h>

class CExprFactoryHelper
{
public:
    // construction

    CExprFactoryHelper(std::string name, cbit_constructor_t _Constructor);
    CExprFactoryHelper(std::string, value_constructor_t _Constructor);
    CExprFactoryHelper(std::string, operator_constructor_t _Constructor);
};

Detailed Documentation

CExpr factory helper Provide CExprFactory class registration interface for the outside.

Construction

CExprFactoryHelper(std::string name, cbit_constructor_t _Constructor)

Construct a new CExprFactoryHelper object Call the CExprFactory class registration interface for register the CExpr subclass.

Parameters:

std::string	subclass name
cbit_constructor_t	function

CExprFactoryHelper(std::string, value_constructor_t _Constructor)

Construct a new CExprFactoryHelper object Call the CExprFactory class registration interface for register the CExpr subclass.

Parameters:

std::string	subclass name
value_constructor_t	function

CExprFactoryHelper(std::string, operator_constructor_t _Constructor)

Construct a new CExprFactoryHelper object Call the CExprFactory class registration interface for register the CExpr subclass.

Parameters:

std::string	subclass name
operator_constructor_t	function

class QPanda::ClassicalCondition

Overview

Classical condition class Proxy class of cexpr class. More…

#include <ClassicalConditionInterface.h>

class ClassicalCondition
{
public:
    // construction

    ClassicalCondition(CBit* cbit);
    ClassicalCondition(cbit_size_t value);
    ClassicalCondition(CExpr* cexpr);
    ClassicalCondition(const ClassicalCondition& old);

    // methods

    std::shared_ptr<CExpr> getExprPtr() const;
    cbit_size_t get_val();
    void set_val(cbit_size_t);
    bool checkValidity() const;
    ClassicalCondition operator = (ClassicalCondition old);
    ClassicalCondition operator = (const cbit_size_t value);
};

Detailed Documentation

Classical condition class Proxy class of cexpr class.

Construction

ClassicalCondition(CBit* cbit)

Construct a new Classical Condition object by cbit.

Parameters:

cbit	target cbit ptr

ClassicalCondition(cbit_size_t value)

Construct a new Classical Condition object by valie.

Parameters:

cbit	target cbit ptr

ClassicalCondition(CExpr* cexpr)

Construct a new Classical Condition object by CExpr.

Parameters:

cexpr

target cexpr ptr

ClassicalCondition(const ClassicalCondition& old)

Construct a new Classical Condition object by ClassicalCondition.

Parameters:

old	target ClassicalCondition object

Methods

std::shared_ptr<CExpr> getExprPtr() const

Get the Expr Ptr.

Returns:

std::shared_ptr<CExpr>

cbit_size_t get_val()

Get the value of the current object.

Returns:

cbit_size_t

void set_val(cbit_size_t)

Set the Value of the current object.

bool checkValidity() const

Check validity.

Returns:

true check validity ture

false check validity false

ClassicalCondition operator = (ClassicalCondition old)

ClassicalCondition assgen function by ClassicalCondition.

Parameters:

old	target ClassicalCondition object

Returns:

ClassicalCondition

ClassicalCondition operator = (const cbit_size_t value)

ClassicalCondition assgen function by value.

Parameters:

value

target value

Returns:

ClassicalCondition

class QPanda::ClassicalProg

Overview

Classical program class. More…

#include <ClassicalProgram.h>

class ClassicalProg: public QPanda::AbstractClassicalProg
{
public:
    // construction

    ClassicalProg(ClassicalCondition& classical_cond);
    ClassicalProg(const ClassicalProg& old);
    ClassicalProg(std::shared_ptr<AbstractClassicalProg> node);

    // methods

    NodeType getNodeType() const;
    std::shared_ptr<AbstractClassicalProg> getImplementationPtr();
    virtual cbit_size_t get_val();
    virtual std::shared_ptr<CExpr> getExpr();
};

Inherited Members

public:
    // methods

    virtual std::shared_ptr<CExpr> getExpr() = 0;
    virtual cbit_size_t get_val() = 0;

Detailed Documentation

Classical program class.

The proxy class of the AbstractClassicalProg implementation class

Construction

ClassicalProg(ClassicalCondition& classical_cond)

Construct a new Classical Prog object.

Parameters:

classical_cond

Target classical condition

ClassicalProg(const ClassicalProg& old)

Construct a new Classical Prog object.

Parameters:

old	Target classical program

Methods

NodeType getNodeType() const

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

virtual cbit_size_t get_val()

Get classical program value.

Returns:

cbit_size_t

virtual std::shared_ptr<CExpr> getExpr()

Get classical expr shared ptr.

Returns:

std::shared_ptr<CExpr>

class QPanda::ClassicalProgFactory

Overview

Factory for class AbstractClassicalProg. More…

#include <ClassicalProgram.h>

class ClassicalProgFactory
{
public:
    // methods

    void registClass(
        std::string name,
        CreateClassicalQProgram method
        );

    AbstractClassicalProg* getClassicalProgm(
        std::string& name,
        ClassicalCondition& classical_cond
        );

    static ClassicalProgFactory& getInstance();
};

Detailed Documentation

Factory for class AbstractClassicalProg.

Methods

static ClassicalProgFactory& getInstance()

Get the static instance of factory.

Returns:

ClassicalProgFactory &

class QPanda::ClassicalProgRegisterAction

classical program register action Provide ClassicalProgFactory class registration interface for the outside

#include <ClassicalProgram.h>

class ClassicalProgRegisterAction
{
public:
    // construction

    ClassicalProgRegisterAction(
        std::string className,
        CreateClassicalQProgram ptrCreateFn
        );
};

class QPanda::HadamardQCircuit

Hadamard quantum circuit program.

#include <QCircuit.h>

class HadamardQCircuit: public QPanda::QCircuit
{
public:
    // construction

    HadamardQCircuit(QVec& pQubitVector);
};

Inherited Members

public:
    // methods

    virtual NodeIter getFirstNodeIter() = 0;
    virtual NodeIter getLastNodeIter() = 0;
    virtual NodeIter getEndNodeIter() = 0;
    virtual NodeIter getHeadNodeIter() = 0;
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>) = 0;
    virtual NodeIter deleteQNode(NodeIter&) = 0;
    virtual void pushBackNode(std::shared_ptr<QNode>) = 0;
    virtual bool isDagger() const = 0;
    virtual bool getControlVector(QVec&) = 0;
    virtual void setDagger(bool isDagger) = 0;
    virtual void setControl(QVec) = 0;
    virtual void clearControl() = 0;
    virtual size_t get_used_qubits(QVec&) const = 0;
    virtual size_t get_qgate_num() = 0;
    std::shared_ptr<AbstractQuantumCircuit> getImplementationPtr();
    virtual void pushBackNode(std::shared_ptr<QNode>);

    template <typename T>
    QCircuit& operator << (T node);

    virtual QCircuit dagger();
    virtual QCircuit control(const QVec);
    NodeType getNodeType() const;
    virtual bool isDagger() const;
    virtual bool getControlVector(QVec&);
    virtual NodeIter getFirstNodeIter();
    virtual NodeIter getLastNodeIter();
    virtual NodeIter getEndNodeIter();
    virtual NodeIter getHeadNodeIter();
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>);
    virtual NodeIter deleteQNode(NodeIter&);
    bool is_empty();
    virtual void setDagger(bool isDagger);
    virtual void setControl(const QVec);
    virtual size_t get_used_qubits(QVec&) const;
    virtual size_t get_qgate_num();

class QPanda::Item

Item basic abstract class.

#include <QNode.h>

class Item
{
public:
    // methods

    virtual Item* getNext() const = 0;
    virtual Item* getPre() const = 0;
    virtual std::shared_ptr<QNode> getNode() const = 0;
    virtual void setNext(Item*) = 0;
    virtual void setPre(Item*) = 0;
    virtual void setNode(std::shared_ptr<QNode> pNode) = 0;
};

// direct descendants

class OriginItem;

class QPanda::OriginCExpr

union QPanda::OriginCExpr::content_u

#include <OriginClassicalExpression.h>

union content_u
{
    // fields

    CBit* cbit;
    int iOperatorSpecifier;
    cbit_size_t const_value;
};

Overview

Implementation class of CExpr. More…

#include <OriginClassicalExpression.h>

class OriginCExpr: public QPanda::CExpr
{
public:
    // unions

    union content_u;

    // fields

    NodeType m_node_type;
    qmap_size_t m_postion;

    // construction

    OriginCExpr(CBit* cbit);

    OriginCExpr(
        CExpr* leftExpr,
        CExpr* rightExpr,
        int
        );

    OriginCExpr(cbit_size_t);

    // methods

    virtual CExpr* getLeftExpr() const;
    virtual CExpr* getRightExpr() const;
    virtual std::string getName() const;
    virtual CBit* getCBit() const;
    virtual void setLeftExpr(CExpr* left_expr);
    virtual void setRightExpr(CExpr* right_expr);
    virtual cbit_size_t get_val() const;
    virtual CExpr* deepcopy() const;
    virtual bool checkValidity() const;
    virtual void getCBitsName(std::vector<std::string>&);
    NodeType getNodeType() const;
    qmap_size_t getPosition() const;
    void setPosition(qmap_size_t);
    virtual int getContentSpecifier() const;
};

Inherited Members

public:
    // methods

    virtual CExpr* getLeftExpr() const = 0;
    virtual CExpr* getRightExpr() const = 0;
    virtual void setLeftExpr(CExpr* left_expr) = 0;
    virtual void setRightExpr(CExpr* right_expr) = 0;
    virtual std::string getName() const = 0;
    virtual CBit* getCBit() const = 0;
    virtual bool checkValidity() const = 0;
    virtual cbit_size_t get_val() const = 0;
    virtual int getContentSpecifier() const = 0;
    virtual CExpr* deepcopy() const = 0;
    virtual void getCBitsName(std::vector<std::string>&) = 0;

Detailed Documentation

Implementation class of CExpr.

Fields

NodeType m_node_type

quantum node type

Methods

virtual CExpr* getLeftExpr() const

Get the Left Expr pointer.

Returns:

CExpr*

virtual CExpr* getRightExpr() const

Get the Right Expr pointer.

Returns:

CExpr*

virtual std::string getName() const

Get the Name object.

Returns:

std::string

virtual CBit* getCBit() const

get classical bit pointer

Returns:

CBit*

virtual void setLeftExpr(CExpr* left_expr)

Set the Left Expr pointer.

Parameters:

CExpr*

left expr

virtual void setRightExpr(CExpr* right_expr)

Set the Right Expr pointer.

Parameters:

CExpr*

right expr

virtual cbit_size_t get_val() const

get value

Returns:

cbit_size_t

virtual CExpr* deepcopy() const

deep copy this cexpr

Returns:

CExpr*

virtual bool checkValidity() const

check validity

Returns:

true check validity ture

false check validity false

virtual void getCBitsName(std::vector<std::string>&)

get all cbits name

Parameters:

std::vector<std::string>

cibts name vector

NodeType getNodeType() const

get quantum node type

Returns:

NodeType

virtual int getContentSpecifier() const

get content specifier

Returns:

NodeType

class QPanda::OriginCircuit

Overview

Implementation class of QCircuit. More…

#include <QCircuit.h>

class OriginCircuit:
    public QPanda::QNode,
    public QPanda::AbstractQuantumCircuit
{
public:
    // methods

    virtual void pushBackNode(std::shared_ptr<QNode>);
    virtual void setDagger(bool isDagger);
    virtual void setControl(QVec);
    virtual NodeType getNodeType() const;
    virtual bool isDagger() const;
    virtual bool getControlVector(QVec&);
    virtual NodeIter getFirstNodeIter();
    virtual NodeIter getLastNodeIter();
    virtual NodeIter getEndNodeIter();
    virtual NodeIter getHeadNodeIter();
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>);
    virtual NodeIter deleteQNode(NodeIter&);
    void clear();
    virtual void clearControl();
    virtual size_t get_used_qubits(QVec&) const;
    virtual size_t get_qgate_num();
    bool check_insert_node_type(std::shared_ptr<QNode> node);
};

Inherited Members

public:
    // methods

    virtual NodeType getNodeType() const = 0;
    virtual NodeIter getFirstNodeIter() = 0;
    virtual NodeIter getLastNodeIter() = 0;
    virtual NodeIter getEndNodeIter() = 0;
    virtual NodeIter getHeadNodeIter() = 0;
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>) = 0;
    virtual NodeIter deleteQNode(NodeIter&) = 0;
    virtual void pushBackNode(std::shared_ptr<QNode>) = 0;
    virtual bool isDagger() const = 0;
    virtual bool getControlVector(QVec&) = 0;
    virtual void setDagger(bool isDagger) = 0;
    virtual void setControl(QVec) = 0;
    virtual void clearControl() = 0;
    virtual size_t get_used_qubits(QVec&) const = 0;
    virtual size_t get_qgate_num() = 0;

Detailed Documentation

Implementation class of QCircuit.

Methods

virtual void pushBackNode(std::shared_ptr<QNode>)

Insert a new Node at the end of current quantum circuit.

Parameters:

QNode*

quantum node

Returns:

void

See also:

QNode

virtual void setDagger(bool isDagger)

Set dagger to current quantum circuit.

Parameters:

bool

is dagger

virtual void setControl(QVec)

Set control qubits to current quantum circuit.

Parameters:

QVec	control qubits vector

See also:

QVec

virtual NodeType getNodeType() const

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

virtual bool isDagger() const

Judge current quantum circuit is dagger.

Returns:

bool

virtual bool getControlVector(QVec&)

Get control vector fron current quantum circuit node.

Parameters:

QVec&

qubits vector

Returns:

bool

See also:

QVec

virtual NodeIter getFirstNodeIter()

Get the first NodeIter.

Returns:

NodeIter

virtual NodeIter getLastNodeIter()

Get the last NodeIter.

Returns:

NodeIter

virtual NodeIter getEndNodeIter()

Get the end NodeIter.

Returns:

NodeIter

virtual NodeIter getHeadNodeIter()

Get the head NodeIter.

Returns:

NodeIter

virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>)

Insert a new QNode at the location specified by NodeIter.

Parameters:

NodeIter&	specified location
std::shared_ptr<QNode>	Inserted QNode

Returns:

NodeIter

virtual NodeIter deleteQNode(NodeIter&)

Delete a QNode at the location specified by NodeIter.

Parameters:

NodeIter&

specified location

Returns:

NodeIter Deleted NodeIter

void clear()

Clear all node in current quantum program node.

Returns:

void

virtual void clearControl()

Clear the control qubits for current quantum circuit.

See also:

QVec

virtual size_t get_used_qubits(QVec&) const

Get the used qubits for current quantum circuit.

Parameters:

QVec	used qubits vector

Returns:

size_t

virtual size_t get_qgate_num()

Get current quantum circuit qgate number.

Returns:

size_t

class QPanda::OriginClassicalProg

Overview

Origin classical program class. More…

#include <ClassicalProgram.h>

class OriginClassicalProg:
    public QPanda::QNode,
    public QPanda::AbstractClassicalProg
{
public:
    // construction

    OriginClassicalProg(ClassicalCondition&);

    // methods

    virtual NodeType getNodeType() const;
    virtual cbit_size_t get_val();
    virtual std::shared_ptr<CExpr> getExpr();
};

Inherited Members

public:
    // methods

    virtual NodeType getNodeType() const = 0;
    virtual std::shared_ptr<CExpr> getExpr() = 0;
    virtual cbit_size_t get_val() = 0;

Detailed Documentation

Origin classical program class.

Implementation class of ClassicalProg This class type can hold classical expr and insert into QNodeMap

Construction

OriginClassicalProg(ClassicalCondition&)

Construct a new Origin Classical Prog object.

Parameters:

classical_cond

Target classical condition

Methods

virtual NodeType getNodeType() const

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

virtual cbit_size_t get_val()

Get classical program value.

Returns:

cbit_size_t

virtual std::shared_ptr<CExpr> getExpr()

Get classical expr shared ptr.

Returns:

std::shared_ptr<CExpr>

class QPanda::OriginItem

Origin item implementation class.

#include <QNode.h>

class OriginItem: public QPanda::Item
{
public:
    // methods

    virtual Item* getNext() const;
    virtual Item* getPre() const;
    virtual std::shared_ptr<QNode> getNode() const;
    virtual void setNext(Item* pItem);
    virtual void setPre(Item* pItem);
    virtual void setNode(std::shared_ptr<QNode> pNode);
};

Inherited Members

public:
    // methods

    virtual Item* getNext() const = 0;
    virtual Item* getPre() const = 0;
    virtual std::shared_ptr<QNode> getNode() const = 0;
    virtual void setNext(Item*) = 0;
    virtual void setPre(Item*) = 0;
    virtual void setNode(std::shared_ptr<QNode> pNode) = 0;

class QPanda::OriginProgram

Overview

Implementation class of QProg. More…

#include <QProgram.h>

class OriginProgram:
    public QPanda::QNode,
    public QPanda::AbstractQuantumProgram
{
public:
    // methods

    virtual void pushBackNode(std::shared_ptr<QNode> node);
    virtual NodeIter getFirstNodeIter();
    virtual NodeIter getLastNodeIter();
    virtual NodeIter getEndNodeIter();
    virtual NodeIter getHeadNodeIter();
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>);
    virtual NodeIter deleteQNode(NodeIter&);
    virtual NodeType getNodeType() const;
    virtual void clear();
    bool check_insert_node_type(std::shared_ptr<QNode> node);
    virtual size_t get_max_qubit_addr();
    virtual size_t get_used_qubits(QVec&);
    virtual size_t get_used_cbits(std::vector<ClassicalCondition>&);
    virtual size_t get_qgate_num();
    virtual std::map<Qubit*, bool> get_measure_pos();
    virtual bool is_measure_last_pos();
    virtual std::vector<std::pair<Qubit*, ClassicalCondition>> get_measure_qubits_cbits();
};

Inherited Members

public:
    // methods

    virtual NodeType getNodeType() const = 0;
    virtual NodeIter getFirstNodeIter() = 0;
    virtual NodeIter getLastNodeIter() = 0;
    virtual NodeIter getEndNodeIter() = 0;
    virtual NodeIter getHeadNodeIter() = 0;
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>) = 0;
    virtual NodeIter deleteQNode(NodeIter&) = 0;
    virtual void pushBackNode(std::shared_ptr<QNode>) = 0;
    virtual void clear() = 0;
    virtual size_t get_max_qubit_addr() = 0;
    virtual size_t get_used_qubits(QVec&) = 0;
    virtual size_t get_used_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t get_qgate_num() = 0;
    virtual bool is_measure_last_pos() = 0;
    virtual std::map<Qubit*, bool> get_measure_pos() = 0;
    virtual std::vector<std::pair<Qubit*, ClassicalCondition>> get_measure_qubits_cbits() = 0;

Detailed Documentation

Implementation class of QProg.

Methods

virtual void pushBackNode(std::shared_ptr<QNode> node)

Insert new node at the end of current quantum program node.

Parameters:

QNode*

quantum node

Returns:

void

See also:

QNode

virtual NodeIter getFirstNodeIter()

Get the first NodeIter.

Returns:

NodeIter

virtual NodeIter getLastNodeIter()

Get the last NodeIter.

Returns:

NodeIter

virtual NodeIter getEndNodeIter()

Get the end NodeIter.

Returns:

NodeIter

virtual NodeIter getHeadNodeIter()

Get the head NodeIter.

Returns:

NodeIter

virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>)

Insert a new QNode at the location specified by NodeIter.

Parameters:

NodeIter&	specified location
std::shared_ptr<QNode>	Inserted QNode

Returns:

NodeIter

virtual NodeIter deleteQNode(NodeIter&)

Delete a QNode at the location specified by NodeIter.

Parameters:

NodeIter&

specified location

Returns:

NodeIter Deleted NodeIter

virtual NodeType getNodeType() const

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

virtual void clear()

Clear all node in current quantum program node.

Returns:

void

virtual size_t get_max_qubit_addr()

Gets the maximum physical address of used qubits.

Returns:

size_t maximum physical address

virtual size_t get_used_qubits(QVec&)

Get the used qubits for current quantum program.

Parameters:

QVec	used qubits vector

Returns:

size_t

virtual size_t get_used_cbits(std::vector<ClassicalCondition>&)

Get the used classical bits for current quantum program.

Parameters:

QVec	used qubits vector

Returns:

size_t

virtual size_t get_qgate_num()

Get current quantum program qgate number.

Returns:

size_t

virtual std::map<Qubit*, bool> get_measure_pos()

Get Measure operation position of the program.

Returns:

std::map<Qubit*, bool>

virtual bool is_measure_last_pos()

Measure operation in the last position of the program.

Returns:

bool

virtual std::vector<std::pair<Qubit*, ClassicalCondition>> get_measure_qubits_cbits()

Get Measure operation qubits and cbits vector.

Returns:

std::vector<std::pair<Qubit*, ClassicalCondition>>

class QPanda::OriginQGate

Overview

Implementation class of QGate. More…

#include <QGate.h>

class OriginQGate:
    public QPanda::QNode,
    public QPanda::AbstractQGateNode
{
public:
    // construction

    OriginQGate(
        QVec&,
        QuantumGate*
        );

    // methods

    virtual NodeType getNodeType() const;
    virtual size_t getQuBitVector(QVec&) const;
    virtual size_t getTargetQubitNum() const;
    virtual size_t getControlQubitNum() const;
    virtual Qubit* popBackQuBit();
    virtual QuantumGate* getQGate() const;
    virtual void setQGate(QuantumGate*);
    virtual bool setDagger(bool);
    virtual bool setControl(QVec);
    virtual bool isDagger() const;
    virtual size_t getControlVector(QVec&) const;
    virtual void PushBackQuBit(Qubit*);
    virtual void remap(QVec);
    virtual void clear_control();
};

Inherited Members

public:
    // methods

    virtual NodeType getNodeType() const = 0;
    virtual size_t getQuBitVector(QVec&) const = 0;
    virtual Qubit* popBackQuBit() = 0;
    virtual void PushBackQuBit(Qubit*) = 0;
    virtual size_t getTargetQubitNum() const = 0;
    virtual size_t getControlQubitNum() const = 0;
    virtual QuantumGate* getQGate() const = 0;
    virtual void setQGate(QuantumGate*) = 0;
    virtual bool isDagger() const = 0;
    virtual size_t getControlVector(QVec&) const = 0;
    virtual void clear_control() = 0;
    virtual bool setDagger(bool) = 0;
    virtual bool setControl(QVec) = 0;
    virtual void remap(QVec) = 0;

Detailed Documentation

Implementation class of QGate.

Methods

virtual NodeType getNodeType() const

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

virtual size_t getQuBitVector(QVec&) const

Get qubit vector inside this quantum gate.

Parameters:

QVec&

qubit vector

Returns:

size_t

See also:

GateType

virtual size_t getTargetQubitNum() const

Get target qubit num inside this quantum gate.

Returns:

size_t qubit num

virtual size_t getControlQubitNum() const

Get control qubit num inside this quantum gate.

Returns:

size_t qubit num

virtual Qubit* popBackQuBit()

erase qubit vector element at end

Returns:

Qubit*

virtual QuantumGate* getQGate() const

Get Quantum Gate.

Returns:

QuantumGate *

virtual void setQGate(QuantumGate*)

Set Quantum Gate.

Parameters:

QuantumGate*

QuantumGate pointer

virtual bool setDagger(bool)

Set dagger to current quantum gate.

Parameters:

bool

is dagger

Returns:

bool

virtual bool setControl(QVec)

Set control qubits to current quantum gate.

Parameters:

QVec	control qubits vector

Returns:

bool

See also:

QVec

virtual bool isDagger() const

Judge current quantum gate is dagger.

Returns:

bool

virtual size_t getControlVector(QVec&) const

Get control vector fron current quantum gate node.

Parameters:

QVec&

qubits vector

Returns:

size_t

See also:

QVec

virtual void PushBackQuBit(Qubit*)

insert qubit vector element at end

Parameters:

Qubit*

Qubit pointer

virtual void remap(QVec)

remap qubit

Returns:

virtual void clear_control()

Clear the control qubits for current quantum gate.

See also:

QVec

class QPanda::OriginQIf

Overview

Implementation class of QIfProg More…

#include <ControlFlow.h>

class OriginQIf:
    public QPanda::QNode,
    public QPanda::AbstractControlFlowNode
{
public:
    // construction

    OriginQIf(
        ClassicalCondition classical_condition,
        QProg true_node,
        QProg false_node
        );

    OriginQIf(
        ClassicalCondition classical_condition,
        QProg node
        );

    // methods

    virtual NodeType getNodeType() const;
    virtual std::shared_ptr<QNode> getTrueBranch() const;
    virtual std::shared_ptr<QNode> getFalseBranch() const;
    virtual void setTrueBranch(QProg node);
    virtual void setFalseBranch(QProg node);
    virtual ClassicalCondition getCExpr();
};

Inherited Members

public:
    // methods

    virtual NodeType getNodeType() const = 0;
    virtual std::shared_ptr<QNode> getTrueBranch() const = 0;
    virtual std::shared_ptr<QNode> getFalseBranch() const = 0;
    virtual void setTrueBranch(QProg node) = 0;
    virtual void setFalseBranch(QProg node) = 0;
    virtual ClassicalCondition getCExpr() = 0;

Detailed Documentation

Implementation class of QIfProg

Methods

virtual NodeType getNodeType() const

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

virtual std::shared_ptr<QNode> getTrueBranch() const

Get true branch.

Returns:

std::shared_ptr<QNode>

virtual std::shared_ptr<QNode> getFalseBranch() const

Get false branch.

Returns:

std::shared_ptr<QNode>

virtual void setTrueBranch(QProg node)

Set the True branch.

Parameters:

Node	True branch node

virtual void setFalseBranch(QProg node)

Set the False Branch object.

Parameters:

Node	False branch node

virtual ClassicalCondition getCExpr()

Get classical expr.

Returns:

ClassicalCondition ptr

class QPanda::OriginQWhile

Overview

Implementation class of QWhileProg. More…

#include <ControlFlow.h>

class OriginQWhile:
    public QPanda::QNode,
    public QPanda::AbstractControlFlowNode
{
public:
    // construction

    OriginQWhile(
        ClassicalCondition ccCon,
        QProg node
        );

    // methods

    virtual NodeType getNodeType() const;
    virtual std::shared_ptr<QNode> getTrueBranch() const;
    virtual std::shared_ptr<QNode> getFalseBranch() const;
    virtual void setTrueBranch(QProg node);
    virtual void setFalseBranch(QProg node);
    virtual ClassicalCondition getCExpr();
};

Inherited Members

public:
    // methods

    virtual NodeType getNodeType() const = 0;
    virtual std::shared_ptr<QNode> getTrueBranch() const = 0;
    virtual std::shared_ptr<QNode> getFalseBranch() const = 0;
    virtual void setTrueBranch(QProg node) = 0;
    virtual void setFalseBranch(QProg node) = 0;
    virtual ClassicalCondition getCExpr() = 0;

Detailed Documentation

Implementation class of QWhileProg.

Methods

virtual NodeType getNodeType() const

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

virtual std::shared_ptr<QNode> getTrueBranch() const

Get true branch.

Returns:

std::shared_ptr<QNode>

virtual std::shared_ptr<QNode> getFalseBranch() const

Get false branch.

Returns:

std::shared_ptr<QNode>

virtual void setTrueBranch(QProg node)

Set the True branch.

Parameters:

Node	True branch node

virtual void setFalseBranch(QProg node)

Set the False Branch object.

Parameters:

Node	False branch node

virtual ClassicalCondition getCExpr()

Get classical expr.

Returns:

ClassicalCondition ptr

class QPanda::OriginReset

Overview

Implementation class of QReset. More…

#include <QReset.h>

class OriginReset:
    public QPanda::QNode,
    public QPanda::AbstractQuantumReset
{
public:
    // construction

    OriginReset(Qubit*);

    // methods

    virtual Qubit* getQuBit() const;
    virtual NodeType getNodeType() const;
};

Inherited Members

public:
    // methods

    virtual NodeType getNodeType() const = 0;
    virtual Qubit* getQuBit() const = 0;

Detailed Documentation

Implementation class of QReset.

Methods

virtual Qubit* getQuBit() const

Get reset node qubit address.

Returns:

QPanda::Qubit * QuBit address

virtual NodeType getNodeType() const

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

class QPanda::QCircuit

Overview

Quantum circuit basic abstract class. More…

#include <QCircuit.h>

class QCircuit: public QPanda::AbstractQuantumCircuit
{
public:
    // construction

    QCircuit();
    QCircuit(const QCircuit&);
    QCircuit(QGate& gate);
    QCircuit(std::shared_ptr<AbstractQuantumCircuit> node);

    // methods

    std::shared_ptr<AbstractQuantumCircuit> getImplementationPtr();
    virtual void pushBackNode(std::shared_ptr<QNode>);

    template <typename T>
    QCircuit& operator << (T node);

    virtual QCircuit dagger();
    virtual QCircuit control(const QVec);
    NodeType getNodeType() const;
    virtual bool isDagger() const;
    virtual bool getControlVector(QVec&);
    virtual NodeIter getFirstNodeIter();
    virtual NodeIter getLastNodeIter();
    virtual NodeIter getEndNodeIter();
    virtual NodeIter getHeadNodeIter();
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>);
    virtual NodeIter deleteQNode(NodeIter&);
    bool is_empty();
    virtual void setDagger(bool isDagger);
    virtual void setControl(const QVec);
    virtual size_t get_used_qubits(QVec&) const;
    virtual size_t get_qgate_num();
};

// direct descendants

class HadamardQCircuit;

Inherited Members

public:
    // methods

    virtual NodeIter getFirstNodeIter() = 0;
    virtual NodeIter getLastNodeIter() = 0;
    virtual NodeIter getEndNodeIter() = 0;
    virtual NodeIter getHeadNodeIter() = 0;
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>) = 0;
    virtual NodeIter deleteQNode(NodeIter&) = 0;
    virtual void pushBackNode(std::shared_ptr<QNode>) = 0;
    virtual bool isDagger() const = 0;
    virtual bool getControlVector(QVec&) = 0;
    virtual void setDagger(bool isDagger) = 0;
    virtual void setControl(QVec) = 0;
    virtual void clearControl() = 0;
    virtual size_t get_used_qubits(QVec&) const = 0;
    virtual size_t get_qgate_num() = 0;

Detailed Documentation

Quantum circuit basic abstract class.

Methods

virtual void pushBackNode(std::shared_ptr<QNode>)

Insert new Node at the end of current quantum circuit node.

Parameters:

QNode*

quantum node

Returns:

void

See also:

QNode

template <typename T>
QCircuit& operator << (T node)

Insert new Node at the end of current node.

Parameters:

node	QGate/QCircuit

Returns:

QPanda::QCircuit & quantum circuit

See also:

QNode

virtual QCircuit dagger()

Get a dagger circuit base on current quantum circuit node.

Returns:

QPanda::QCircuit quantum circuit

virtual QCircuit control(const QVec)

Get a control quantumgate base on current quantum circuit node.

Parameters:

QVec	control qubits vector

Returns:

QPanda::QCircuit quantum circuit

See also:

QVec

NodeType getNodeType() const

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

virtual bool isDagger() const

Judge current quantum circuit is dagger.

Returns:

bool

virtual bool getControlVector(QVec&)

Get control vector from current quantum circuit node.

Parameters:

QVec&

qubits vector

Returns:

bool

See also:

QVec

virtual NodeIter getFirstNodeIter()

Get the first NodeIter.

Returns:

NodeIter

virtual NodeIter getLastNodeIter()

Get the last NodeIter.

Returns:

NodeIter

virtual NodeIter getEndNodeIter()

Get the end NodeIter.

Returns:

NodeIter

virtual NodeIter getHeadNodeIter()

Get the head NodeIter.

Returns:

NodeIter

virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>)

Insert a new QNode at the location specified by NodeIter.

Parameters:

NodeIter&	specified location
std::shared_ptr<QNode>	Inserted QNode

Returns:

NodeIter

virtual NodeIter deleteQNode(NodeIter&)

Delete a QNode at the location specified by NodeIter.

Parameters:

NodeIter&

specified location

Returns:

NodeIter Deleted NodeIter

virtual void setDagger(bool isDagger)

Set dagger to current quantum circuit.

Parameters:

bool

is dagger

virtual void setControl(const QVec)

Set control qubits to current quantum circuit.

Parameters:

QVec	control qubits vector

See also:

QVec

virtual size_t get_used_qubits(QVec&) const

Get the used qubits for current quantum circuit.

Parameters:

QVec	used qubits vector

Returns:

size_t

virtual size_t get_qgate_num()

Get current quantum circuit qgate number.

Returns:

size_t

class QPanda::QGate

Overview

QPanda2 quantum gate basic classs. More…

#include <QGate.h>

class QGate: public QPanda::AbstractQGateNode
{
public:
    // construction

    QGate(const QGate&);

    QGate(
        QVec&,
        QuantumGate*
        );

    QGate(std::shared_ptr<AbstractQGateNode> node);

    // methods

    NodeType getNodeType() const;
    virtual size_t getQuBitVector(QVec&) const;
    virtual size_t getTargetQubitNum() const;
    virtual size_t getControlQubitNum() const;
    virtual QuantumGate* getQGate() const;
    virtual bool setDagger(bool);
    virtual bool setControl(QVec);
    std::shared_ptr<AbstractQGateNode> getImplementationPtr();
    QGate dagger();
    QGate control(QVec);
    virtual void clear_control();
    virtual void remap(QVec);
    virtual bool isDagger() const;
    virtual size_t getControlVector(QVec&) const;
};

Inherited Members

public:
    // methods

    virtual size_t getQuBitVector(QVec&) const = 0;
    virtual Qubit* popBackQuBit() = 0;
    virtual void PushBackQuBit(Qubit*) = 0;
    virtual size_t getTargetQubitNum() const = 0;
    virtual size_t getControlQubitNum() const = 0;
    virtual QuantumGate* getQGate() const = 0;
    virtual void setQGate(QuantumGate*) = 0;
    virtual bool isDagger() const = 0;
    virtual size_t getControlVector(QVec&) const = 0;
    virtual void clear_control() = 0;
    virtual bool setDagger(bool) = 0;
    virtual bool setControl(QVec) = 0;
    virtual void remap(QVec) = 0;

Detailed Documentation

QPanda2 quantum gate basic classs.

Methods

NodeType getNodeType() const

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

virtual size_t getQuBitVector(QVec&) const

Get qubit vector inside this quantum gate.

Parameters:

QVec&

qubit vector

Returns:

size_t

See also:

GateType

virtual size_t getTargetQubitNum() const

Get qubit num inside this quantum gate.

Returns:

size_t qubit num

virtual size_t getControlQubitNum() const

Get control qubit num inside this quantum gate.

Returns:

size_t qubit num

virtual QuantumGate* getQGate() const

Get Quantum Gate.

Returns:

QuantumGate *

virtual bool setDagger(bool)

Set dagger to current quantum gate.

Parameters:

bool

is dagger

Returns:

bool

virtual bool setControl(QVec)

Set control qubits to current quantum gate.

Parameters:

QVec	control qubits vector

Returns:

bool

See also:

QVec

QGate dagger()

Get a dagger quantumgate base on current quantum gate node.

Returns:

QPanda::QGate quantum gate

QGate control(QVec)

Get a control quantumgate base on current quantum gate node.

Parameters:

QVec	control qubits vector

Returns:

QPanda::QGate quantum gate

See also:

QVec

virtual void clear_control()

Clear the control qubits for current quantum gate.

Returns:

virtual void remap(QVec)

remap qubit

Returns:

virtual bool isDagger() const

Judge current quantum gate is dagger.

Returns:

bool

virtual size_t getControlVector(QVec&) const

Get control vector fron current quantum gate node.

Parameters:

QVec&

qubits vector

Returns:

size_t

See also:

QVec

template class QGATE_SPACE::QGateFactory

Quantum Gate Factory.

#include <QuantumGate.h>

template <typename ... Targs>
class QGateFactory
{
public:
    // methods

    bool registClass(
        const std::string& type_name,
        std::function<QuantumGate*(Targs&&... args)> function
        );

    QuantumGate* getGateNode(
        const std::string& type_name,
        Targs&&... args
        );

    static QGateFactory* getInstance();
};

class QPanda::QGateNodeFactory

Overview

Factory for class QGate. More…

#include <QGate.h>

class QGateNodeFactory
{
public:
    // methods

    static QGateNodeFactory* getInstance();

    template <typename ... Targs>
    QGate getGateNode(
        const std::string& name,
        QVec qs,
        Targs&&... args
        );
};

Detailed Documentation

Factory for class QGate.

Methods

static QGateNodeFactory* getInstance()

Get the static instance of factory.

Returns:

QGateNodeFactory *

class QPanda::QIfFactory

Overview

Factory for class AbstractControlFlowNode. More…

#include <ControlFlow.h>

class QIfFactory
{
public:
    // methods

    void registClass(
        std::string name,
        CreateQIfTrueFalse_cb method
        );

    void registClass(
        std::string name,
        CreateQIfTrueOnly_cb method
        );

    AbstractControlFlowNode* getQIf(
        std::string& class_name,
        ClassicalCondition& classical_condition,
        QProg true_node,
        QProg false_node
        );

    AbstractControlFlowNode* getQIf(
        std::string& name,
        ClassicalCondition& classical_cond,
        QProg node
        );

    static QIfFactory& getInstance();
};

Detailed Documentation

Factory for class AbstractControlFlowNode.

Methods

static QIfFactory& getInstance()

Get the static instance of factory.

Returns:

QIfFactory &

class QPanda::QIfProg

Overview

Proxy class of quantum if program. More…

#include <ControlFlow.h>

class QIfProg: public QPanda::AbstractControlFlowNode
{
public:
    // construction

    QIfProg(const QIfProg& old);
    QIfProg(std::shared_ptr<AbstractControlFlowNode> qif);
    QIfProg(ClassicalCondition classical_condition, QProg true_node, QProg false_node);
    QIfProg(ClassicalCondition classical_condition, QProg node);

    // methods

    virtual NodeType getNodeType() const;
    virtual std::shared_ptr<QNode> getTrueBranch() const;
    virtual std::shared_ptr<QNode> getFalseBranch() const;
    std::shared_ptr<AbstractControlFlowNode> getImplementationPtr();
    virtual ClassicalCondition getCExpr();
    virtual ClassicalCondition getClassicalCondition();
};

Inherited Members

public:
    // methods

    virtual std::shared_ptr<QNode> getTrueBranch() const = 0;
    virtual std::shared_ptr<QNode> getFalseBranch() const = 0;
    virtual void setTrueBranch(QProg node) = 0;
    virtual void setFalseBranch(QProg node) = 0;
    virtual ClassicalCondition getCExpr() = 0;

Detailed Documentation

Proxy class of quantum if program.

Construction

QIfProg(const QIfProg& old)

Construct a new QIfProg object.

Parameters:

old	Target QIfProg

QIfProg(ClassicalCondition classical_condition, QProg true_node, QProg false_node)

Construct a new QIfProg.

Parameters:

classical_condition	this QIfProg classical condition
true_node	true branch node
false_node	false branch node

QIfProg(ClassicalCondition classical_condition, QProg node)

Construct a new QIfProg object.

Parameters:

classical_condition	this QIfProg classical condition
node	true branch node

Methods

virtual NodeType getNodeType() const

Get the current node type.

Returns:

NodeType

virtual std::shared_ptr<QNode> getTrueBranch() const

Get the True Branch.

Returns:

std::shared_ptr<QNode>

virtual std::shared_ptr<QNode> getFalseBranch() const

Get the False Branch.

Returns:

std::shared_ptr<QNode>

virtual ClassicalCondition getCExpr()

Get classical expr.

Returns:

ClassicalCondition ptr

virtual ClassicalCondition getClassicalCondition()

get a classical condition

Returns:

ClassicalCondition

class QPanda::QIfRegisterAction

Overview

QIf program register action. More…

#include <ControlFlow.h>

class QIfRegisterAction
{
public:
    // construction

    QIfRegisterAction(std::string class_name, CreateQIfTrueFalse_cb create_callback);
    QIfRegisterAction(std::string class_name, CreateQIfTrueOnly_cb create_callback);
};

Detailed Documentation

QIf program register action.

Provide QIfFactory class registration interface for the outside

Construction

QIfRegisterAction(std::string class_name, CreateQIfTrueFalse_cb create_callback)

Construct a new QIfRegisterAction object Call QIfFactory`s registClass interface.

Parameters:

class_name	AbstractControlFlowNode Implementation class name
create_callback	The Constructor of Implementation class for AbstractControlFlowNode which have true and false branch

QIfRegisterAction(std::string class_name, CreateQIfTrueOnly_cb create_callback)

Construct a new QIfRegisterAction object Call QIfFactory`s registClass interface.

Parameters:

class_name	AbstractControlFlowNode Implementation class name
create_callback	The Constructor of Implementation class for AbstractControlFlowNode which only have branch

class QPanda::QMeasure

Overview

Quantum Measure basic class. More…

#include <QuantumMeasure.h>

class QMeasure: public QPanda::AbstractQuantumMeasure
{
public:
    // construction

    QMeasure(const QMeasure&);

    QMeasure(
        Qubit*,
        CBit*
        );

    QMeasure(std::shared_ptr<AbstractQuantumMeasure> node);

    // methods

    std::shared_ptr<AbstractQuantumMeasure> getImplementationPtr();
    virtual Qubit* getQuBit() const;
    virtual CBit* getCBit() const;
    NodeType getNodeType() const;
};

Inherited Members

public:
    // methods

    virtual Qubit* getQuBit() const = 0;
    virtual CBit* getCBit() const = 0;

Detailed Documentation

Quantum Measure basic class.

Methods

virtual Qubit* getQuBit() const

Get measure node qubit address.

Returns:

Qubit *

virtual CBit* getCBit() const

Get measure node cbit address.

Returns:

CBit *

class QPanda::QNode

Overview

Quantum node basic abstract class. More…

#include <QNode.h>

class QNode: public QPanda::QObject
{
public:
    // methods

    virtual NodeType getNodeType() const = 0;
};

// direct descendants

class OriginCircuit;
class OriginClassicalProg;
class OriginMeasure;
class OriginProgram;
class OriginQGate;
class OriginQIf;
class OriginQWhile;
class OriginReset;

Detailed Documentation

Quantum node basic abstract class.

Methods

virtual NodeType getNodeType() const = 0

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

class QPanda::QNodeDeepCopy

Overview

Deep copy interface for classess based on QNode. More…

#include <QNodeDeepCopy.h>

class QNodeDeepCopy: public QPanda::TraversalInterface
{
public:
    // methods

    std::shared_ptr<QNode> executeQNode(std::shared_ptr<QNode> node);
    QGate copy_node(std::shared_ptr<AbstractQGateNode>);
    QProg copy_node(std::shared_ptr<AbstractQuantumProgram>);
    QMeasure copy_node(std::shared_ptr<AbstractQuantumMeasure>);
    QReset copy_node(std::shared_ptr<AbstractQuantumReset>);
    QCircuit copy_node(std::shared_ptr<AbstractQuantumCircuit>);
    std::shared_ptr<AbstractControlFlowNode> copy_node(std::shared_ptr<AbstractControlFlowNode>);
    ClassicalProg copy_node(std::shared_ptr<AbstractClassicalProg>);

    void execute(
        std::shared_ptr<AbstractQGateNode>,
        std::shared_ptr<QNode>
        );

    void execute(
        std::shared_ptr<AbstractClassicalProg>,
        std::shared_ptr<QNode>
        );

    void execute(
        std::shared_ptr<AbstractQuantumCircuit>,
        std::shared_ptr<QNode>
        );

    void execute(
        std::shared_ptr<AbstractQuantumMeasure>,
        std::shared_ptr<QNode>
        );

    void execute(
        std::shared_ptr<AbstractQuantumReset>,
        std::shared_ptr<QNode>
        );

    void execute(
        std::shared_ptr<AbstractControlFlowNode>,
        std::shared_ptr<QNode>
        );

    void execute(
        std::shared_ptr<AbstractQuantumProgram>,
        std::shared_ptr<QNode>
        );
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Deep copy interface for classess based on QNode.

Methods

std::shared_ptr<QNode> executeQNode(std::shared_ptr<QNode> node)

Execute QNode Node.

Parameters:

QNode*

Returns:

std::shared_ptr<QPanda::QNode> new Node

QGate copy_node(std::shared_ptr<AbstractQGateNode>)

Execute Quantum Gate Node.

Parameters:

AbstractQGateNode*

Quantum Gate Node

Returns:

std::shared_ptr<QPanda::QNode> new QNode

QProg copy_node(std::shared_ptr<AbstractQuantumProgram>)

Execute Quantum QProg Node.

Parameters:

AbstractQuantumProgram*

Quantum QProg Node

Returns:

std::shared_ptr<QPanda::QNode> new Node

QMeasure copy_node(std::shared_ptr<AbstractQuantumMeasure>)

Execute Quantum Measure Node.

Parameters:

AbstractQuantumMeasure*

Quantum Measure Node

Returns:

std::shared_ptr<QPanda::QNode> new Node

QReset copy_node(std::shared_ptr<AbstractQuantumReset>)

Execute Quantum Reset Node.

Parameters:

AbstractQuantumReset*

Quantum Reset Node

Returns:

std::shared_ptr<QPanda::QNode> new Node

QCircuit copy_node(std::shared_ptr<AbstractQuantumCircuit>)

Execute Quantum Circuit Node.

Parameters:

AbstractQuantumCircuit*

Quantum Circuit Node

Returns:

std::shared_ptr<QPanda::QNode> new Node

std::shared_ptr<AbstractControlFlowNode> copy_node(std::shared_ptr<AbstractControlFlowNode>)

Execute ControlFlow Node.

Parameters:

AbstractControlFlowNode*

ControlFlow Node

Returns:

std::shared_ptr<QPanda::QNode> new Node

ClassicalProg copy_node(std::shared_ptr<AbstractClassicalProg>)

Execute ClassicalProg Node.

Parameters:

AbstractClassicalProg*

ClassicalProg Node

Returns:

std::shared_ptr<QPanda::QNode> new Node

class QPanda::QProg

Overview

Quantum program,can construct quantum circuit,data struct is linked list. More…

#include <QProgram.h>

class QProg: public QPanda::AbstractQuantumProgram
{
public:
    // construction

    QProg();
    QProg(const QProg&);

    template <typename Ty>
    QProg(Ty& node);

    QProg(std::shared_ptr<QNode>);
    QProg(std::shared_ptr<AbstractQuantumProgram>);
    QProg(ClassicalCondition& node);
    QProg(QProg& other);

    // methods

    std::shared_ptr<AbstractQuantumProgram> getImplementationPtr();
    virtual void pushBackNode(std::shared_ptr<QNode>);

    template <typename T>
    QProg& operator << (T node);

    virtual NodeIter getFirstNodeIter();
    virtual NodeIter getLastNodeIter();
    virtual NodeIter getEndNodeIter();
    virtual NodeIter getHeadNodeIter();
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>);
    virtual NodeIter deleteQNode(NodeIter&);
    NodeType getNodeType() const;
    virtual void clear();
    bool is_empty();
    virtual size_t get_max_qubit_addr();
    virtual size_t get_used_qubits(QVec&);
    virtual size_t get_used_cbits(std::vector<ClassicalCondition>&);
    virtual size_t get_qgate_num();
    virtual bool is_measure_last_pos();
    virtual std::map<Qubit*, bool> get_measure_pos();
    virtual std::vector<std::pair<Qubit*, ClassicalCondition>> get_measure_qubits_cbits();
};

Inherited Members

public:
    // methods

    virtual NodeIter getFirstNodeIter() = 0;
    virtual NodeIter getLastNodeIter() = 0;
    virtual NodeIter getEndNodeIter() = 0;
    virtual NodeIter getHeadNodeIter() = 0;
    virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>) = 0;
    virtual NodeIter deleteQNode(NodeIter&) = 0;
    virtual void pushBackNode(std::shared_ptr<QNode>) = 0;
    virtual void clear() = 0;
    virtual size_t get_max_qubit_addr() = 0;
    virtual size_t get_used_qubits(QVec&) = 0;
    virtual size_t get_used_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t get_qgate_num() = 0;
    virtual bool is_measure_last_pos() = 0;
    virtual std::map<Qubit*, bool> get_measure_pos() = 0;
    virtual std::vector<std::pair<Qubit*, ClassicalCondition>> get_measure_qubits_cbits() = 0;

Detailed Documentation

Quantum program,can construct quantum circuit,data struct is linked list.

Methods

virtual void pushBackNode(std::shared_ptr<QNode>)

Insert a new Node at the end of current quantum circuit.

Parameters:

QNode*

quantum node

Returns:

void

See also:

QNode

template <typename T>
QProg& operator << (T node)

Insert new Node at the end of current node.

if T_GATE is QSingleGateNode/QDoubleGateNode/QIfEndNode, deep copy T_GATE and insert it into left QProg; if T_GATE is QIfProg/QWhileProg/QProg,deepcopy IF/WHILE/QProg circuit and insert it into left QProg

Parameters:

Node	QGate/QCircuit/QProg/QIf/QWhile

Returns:

QPanda::QProg & quantum program

See also:

QNode

virtual NodeIter getFirstNodeIter()

Get the first NodeIter.

Returns:

NodeIter

virtual NodeIter getLastNodeIter()

Get the last NodeIter.

Returns:

NodeIter

virtual NodeIter getEndNodeIter()

Get the end NodeIter.

Returns:

NodeIter

virtual NodeIter getHeadNodeIter()

Get the head NodeIter.

Returns:

NodeIter

virtual NodeIter insertQNode(const NodeIter&, std::shared_ptr<QNode>)

Insert a new QNode at the location specified by NodeIter.

Parameters:

NodeIter&	specified location
std::shared_ptr<QNode>	Inserted QNode

Returns:

NodeIter

virtual NodeIter deleteQNode(NodeIter&)

Delete a QNode at the location specified by NodeIter.

Parameters:

NodeIter&

specified location

Returns:

NodeIter Deleted NodeIter

virtual void clear()

Clear all node in current quantum program node.

virtual size_t get_max_qubit_addr()

Gets the maximum physical address of used qubits.

Returns:

size_t maximum physical address

virtual size_t get_used_qubits(QVec&)

Get the used qubits for current quantum program.

Parameters:

QVec	used qubits vector

Returns:

size_t

virtual size_t get_used_cbits(std::vector<ClassicalCondition>&)

Get the used classical bits for current quantum program.

Parameters:

QVec	used qubits vector

Returns:

size_t

virtual size_t get_qgate_num()

Get current quantum program qgate number.

Returns:

size_t

virtual bool is_measure_last_pos()

Measure operation in the last position of the program.

Returns:

bool

virtual std::map<Qubit*, bool> get_measure_pos()

Get Measure operation position of the program.

Returns:

std::map<Qubit*, bool>

virtual std::vector<std::pair<Qubit*, ClassicalCondition>> get_measure_qubits_cbits()

Get Measure operation qubits and cbits vector.

Returns:

std::vector<std::pair<Qubit*, ClassicalCondition>>

class QPanda::QReset

Overview

Quantum Reset basic class. More…

#include <QReset.h>

class QReset: public QPanda::AbstractQuantumReset
{
public:
    // construction

    QReset();
    QReset(const QReset&);
    QReset(Qubit*);
    QReset(std::shared_ptr<AbstractQuantumReset> node);

    // methods

    std::shared_ptr<AbstractQuantumReset> getImplementationPtr();
    virtual Qubit* getQuBit() const;
    NodeType getNodeType() const;
};

Inherited Members

public:
    // methods

    virtual Qubit* getQuBit() const = 0;

Detailed Documentation

Quantum Reset basic class.

Methods

virtual Qubit* getQuBit() const

Get reset node qubit address.

Returns:

QPanda::Qubit * QuBit address

NodeType getNodeType() const

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

class QPanda::QResetFactory

Overview

Factory for class AbstractQuantumReset. More…

#include <QReset.h>

class QResetFactory
{
public:
    // methods

    void registClass(
        std::string name,
        CreateReset method
        );

    AbstractQuantumReset* getQuantumReset(
        std::string&,
        Qubit*
        );

    static QResetFactory& getInstance();
};

Detailed Documentation

Factory for class AbstractQuantumReset.

Methods

static QResetFactory& getInstance()

Get the static instance of factory.

Returns:

QResetFactory &

class QPanda::QWhileFactory

QWhile factory.

#include <ControlFlow.h>

class QWhileFactory
{
public:
    // methods

    void registClass(
        std::string name,
        CreateQWhile_cb method
        );

    AbstractControlFlowNode* getQWhile(
        std::string&,
        ClassicalCondition&,
        QProg
        );

    static QWhileFactory& getInstance();
};

class QPanda::QWhileProg

Overview

Proxy class of quantum while program. More…

#include <ControlFlow.h>

class QWhileProg: public QPanda::AbstractControlFlowNode
{
public:
    // construction

    QWhileProg(const QWhileProg&);
    QWhileProg(std::shared_ptr<AbstractControlFlowNode> qwhile);

    QWhileProg(
        ClassicalCondition,
        QProg
        );

    // methods

    std::shared_ptr<AbstractControlFlowNode> getImplementationPtr();
    virtual NodeType getNodeType() const;
    virtual std::shared_ptr<QNode> getTrueBranch() const;
    virtual std::shared_ptr<QNode> getFalseBranch() const;
    virtual ClassicalCondition getCExpr();
    virtual ClassicalCondition getClassicalCondition();
};

Inherited Members

public:
    // methods

    virtual std::shared_ptr<QNode> getTrueBranch() const = 0;
    virtual std::shared_ptr<QNode> getFalseBranch() const = 0;
    virtual void setTrueBranch(QProg node) = 0;
    virtual void setFalseBranch(QProg node) = 0;
    virtual ClassicalCondition getCExpr() = 0;

Detailed Documentation

Proxy class of quantum while program.

Methods

virtual std::shared_ptr<QNode> getTrueBranch() const

Get true branch.

Returns:

std::shared_ptr<QNode>

virtual std::shared_ptr<QNode> getFalseBranch() const

Get false branch.

Returns:

std::shared_ptr<QNode>

virtual ClassicalCondition getCExpr()

Get classical expr.

Returns:

ClassicalCondition ptr

class QPanda::QuantumCircuitFactory

Overview

Factory for class AbstractQuantumCircuit. More…

#include <QCircuit.h>

class QuantumCircuitFactory
{
public:
    // methods

    void registClass(
        std::string name,
        CreateQCircuit method
        );

    AbstractQuantumCircuit* getQuantumCircuit(std::string&);
    static QuantumCircuitFactory& getInstance();
};

Detailed Documentation

Factory for class AbstractQuantumCircuit.

Methods

static QuantumCircuitFactory& getInstance()

Get the static instance of factory.

Returns:

QuantumCircuitFactory &

class QGATE_SPACE::QuantumGate

Quantum gate basic abstract class.

#include <QuantumGate.h>

class QuantumGate
{
public:
    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
};

// direct descendants

class OracularGate;
class QDoubleGate;
class U4;

class QPanda::QuantumMeasureFactory

Overview

Factory for class AbstractQuantumMeasure. More…

#include <QuantumMeasure.h>

class QuantumMeasureFactory
{
public:
    // methods

    void registClass(
        std::string name,
        CreateMeasure method
        );

    AbstractQuantumMeasure* getQuantumMeasure(
        std::string&,
        Qubit*,
        CBit*
        );

    static QuantumMeasureFactory& getInstance();
};

Detailed Documentation

Factory for class AbstractQuantumMeasure.

Methods

static QuantumMeasureFactory& getInstance()

Get the static instance of factory.

Returns:

QuantumMeasureFactory &

class QPanda::QuantumProgramFactory

Overview

Factory for class AbstractQuantumProgram. More…

#include <QProgram.h>

class QuantumProgramFactory
{
public:
    // methods

    void registClass(
        std::string name,
        CreateQProgram method
        );

    AbstractQuantumProgram* getQuantumQProg(std::string&);
    static QuantumProgramFactory& getInstance();
};

Detailed Documentation

Factory for class AbstractQuantumProgram.

Methods

static QuantumProgramFactory& getInstance()

Get the static instance of factory.

Returns:

QuantumProgramFactory &

Overview

QPanda2 quantum circuit and quantum program. More…

// classes

class QGATE_SPACE::AbstractAngleParameter;
class QPanda::AbstractClassicalProg;
class QPanda::AbstractControlFlowNode;
class QPanda::AbstractNodeManager;
class QPanda::AbstractQGateNode;
class QPanda::AbstractQuantumCircuit;
class QPanda::AbstractQuantumMeasure;
class QPanda::AbstractQuantumProgram;
class QPanda::AbstractQuantumReset;
class QPanda::CExpr;
class QPanda::CExprFactory;
class QPanda::CExprFactoryHelper;
class QPanda::ClassicalCondition;
class QPanda::ClassicalProg;
class QPanda::ClassicalProgFactory;
class QPanda::ClassicalProgRegisterAction;
class QPanda::HadamardQCircuit;
class QPanda::Item;
class QPanda::OriginCExpr;
class QPanda::OriginCircuit;
class QPanda::OriginClassicalProg;
class QPanda::OriginItem;
class QPanda::OriginProgram;
class QPanda::OriginQGate;
class QPanda::OriginQIf;
class QPanda::OriginQWhile;
class QPanda::OriginReset;
class QPanda::QCircuit;
class QPanda::QGate;

template <typename ... Targs>
class QGATE_SPACE::QGateFactory;

class QPanda::QGateNodeFactory;
class QPanda::QIfFactory;
class QPanda::QIfProg;
class QPanda::QIfRegisterAction;
class QPanda::QMeasure;
class QPanda::QNode;
class QPanda::QNodeDeepCopy;
class QPanda::QProg;
class QPanda::QReset;
class QPanda::QResetFactory;
class QPanda::QWhileFactory;
class QPanda::QWhileProg;
class QPanda::QuantumCircuitFactory;
class QGATE_SPACE::QuantumGate;
class QPanda::QuantumMeasureFactory;
class QPanda::QuantumProgramFactory;

// global functions

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

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

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

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

QProg QPanda::createEmptyQProg();
QReset QPanda::Reset(Qubit*);
QReset QPanda::Reset(int qaddr);

Detailed Documentation

QPanda2 quantum circuit and quantum program.

Global Functions

QIfProg QPanda::createIfProg(ClassicalCondition cc, QProg true_node)

QPanda2 basic interface for creating a QIf program.

Parameters:

ClassicalCondition	Cbit
QProg	QIf true node

Returns:

QIfProg QIf program

QIfProg QPanda::createIfProg(ClassicalCondition cc, QProg true_node, QProg false_node)

QPanda2 basic interface for creating a QIf program.

Parameters:

ClassicalCondition	Cbit
QProg	QIf true node
QProg	QIf false node

Returns:

QIfProg QIf program

QWhileProg QPanda::createWhileProg(ClassicalCondition cc, QProg true_node)

QPanda2 basic interface for creating a QWhile program.

Parameters:

ClassicalCondition	Cbit
QProg	QWhile true node

Returns:

QWhileProg QWhile program

QCircuit QPanda::createEmptyCircuit()

QPanda2 basic interface for creating a empty circuit.

Returns:

QPanda::QCircuit

HadamardQCircuit QPanda::createHadamardQCircuit(QVec& pQubitVector)

Create a hadamard qcircuit.

Parameters:

QVec&

qubit vector

Returns:

QPanda::HadamardQCircuit hadamard qcircuit

QGate QPanda::I(Qubit* qubit)

Construct a new I gate.

Parameters:

Qubit*

qubit target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::X(Qubit* qubit)

Construct a new quantum X gate.

Parameters:

Qubit*

qubit target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::X1(Qubit* qubit)

Construct a new quantum X1 gate.

Parameters:

Qubit*

qubit target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::RX(Qubit*, double angle)

Construct a new quantum RX gate.

Parameters:

Qubit*	target qubit
double	angle

Returns:

QPanda::QGate quantum gate

QGate QPanda::U1(Qubit*, double angle)

Construct a new quantum U1 gate.

Parameters:

Qubit*	target qubit
double	angle

Returns:

QPanda::QGate quantum gate

QGate QPanda::U2(Qubit* qubit, double phi, double lambda)

Construct a new quantum U2 gate.

Parameters:

Qubit*	target qubit
double	phi
double	lambda

Returns:

QPanda::QGate quantum gate

QGate QPanda::U3(Qubit* qubit, double theta, double phi, double lambda)

Construct a new quantum U3 gate.

Parameters:

Qubit*	target qubit
double	theta
double	phi
double	lambda

Returns:

QPanda::QGate quantum gate

QGate QPanda::Y(Qubit* qubit)

Construct a new quantum Y gate.

Parameters:

Qubit*

qubit target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::Y1(Qubit* qubit)

Construct a new quantum Y1 gate.

Parameters:

Qubit*

qubit target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::RY(Qubit*, double angle)

Construct a new quantum RY gate.

Parameters:

Qubit*	target qubit
double	angle target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::Z(Qubit* qubit)

Construct a new quantum Z gate.

Parameters:

Qubit*

qubit target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::Z1(Qubit* qubit)

Construct a new quantum Z1 gate.

Parameters:

Qubit*

qubit target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::RZ(Qubit*, double angle)

Construct a new quantum RZ gate.

Parameters:

Qubit*	target qubit
double	angle

Returns:

QPanda::QGate quantum gate

QGate QPanda::RPhi(Qubit* qubit, double angle, double phi)

Construct a new quantum RZPhi gate.

Parameters:

Qubit*	target qubit
double	angle
double	phi

Returns:

QPanda::QGate quantum gate

QGate QPanda::S(Qubit* qubit)

Construct a new quantum S gate.

Parameters:

Qubit*

qubit target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::T(Qubit*)

Construct a new quantum T gate.

Parameters:

Qubit*

target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::H(Qubit* qubit)

Construct a new quantum H gate.

Parameters:

Qubit*

qubit target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::ECHO(Qubit* qubit)

Construct a new quantum ECHO gate; Only for 6 qubits online projects !

Parameters:

Qubit*

qubit target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::BARRIER(Qubit* qubit)

Construct a new quantum BARRIER gate; Only for 6 qubits online projects !

Parameters:

Qubit*

qubit target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::BARRIER(QVec qubits)

Construct a new quantum BARRIER gate; Only for 6 qubits online projects !

Parameters:

Qubit*

qubit target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::CNOT(Qubit* control_qubit, Qubit* target_qubit)

Construct a new quantum CNOT gate.

Parameters:

Qubit*	control qubit
Qubit*	target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::CZ(Qubit* control_qubit, Qubit* target_qubit)

Construct a new quantum CZ gate.

Parameters:

Qubit*	control qubit
Qubit*	target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::U4(double alpha, double beta, double gamma, double delta, Qubit*)

Construct a new quantum U4 gate.

Parameters:

double	alpha
double	beta
double	gamma
double	delta
Qubit*	target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::U4(QStat& matrix, Qubit*)

Construct a new quantum U4 gate.

Parameters:

QStat&	matrix
Qubit*	target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::QDouble(QStat& matrix, Qubit* qubit1, Qubit* qubit2)

Construct a new quantum QDouble gate.

Parameters:

QStat	matrix
Qubit*	control qubit
Qubit*	target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::CU(double alpha, double beta, double gamma, double delta, Qubit*, Qubit*)

Construct a new quantum CU gate.

Parameters:

double	alpha
double	beta
double	gamma
double	delta
Qubit*	control qubit
Qubit*	target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::CU(QStat& matrix, Qubit*, Qubit*)

Construct a new quantum CU gate.

Parameters:

QStat	& matrix
Qubit*	target qubit
Qubit*	control qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::iSWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second, double theta)

Construct a new quantum iSWAP gate.

Parameters:

Qubit*	control qubit
Qubit*	target qubit
double	theta

Returns:

QPanda::QGate quantum gate

QGate QPanda::CR(Qubit* control_qubit, Qubit* targit_qubit, double theta)

Construct a new quantum CR gate.

Parameters:

Qubit*	control qubit
Qubit*	targit qubit
double	theta

Returns:

QPanda::QGate quantum gate

QGate QPanda::SqiSWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second)

Construct a new quantum SqiSWAP gate.

Parameters:

Qubit*	control qubit
Qubit*	target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::SWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second)

Construct a new quantum SWAP gate.

Parameters:

Qubit*	control qubit
Qubit*	target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::U4(Qubit*, double alpha, double beta, double gamma, double delta)

Construct a new quantum U4 gate.

Parameters:

Qubit*	target qubit
double	alpha
double	beta
double	gamma
double	delta

Returns:

QPanda::QGate quantum gate

QGate QPanda::U4(Qubit*, QStat& matrix)

Construct a new quantum U4 gate.

Parameters:

Qubit*	target qubit
QStat&	matrix

Returns:

QPanda::QGate quantum gate

QGate QPanda::QDouble(Qubit* qubit1, Qubit* qubit2, QStat& matrix)

Construct a new quantum QDouble gate.

Parameters:

Qubit*	control qubit
Qubit*	target qubit
QStat	matrix

Returns:

QPanda::QGate quantum gate

QGate QPanda::CU(Qubit*, Qubit*, double alpha, double beta, double gamma, double delta)

Construct a new quantum CU gate.

Parameters:

Qubit*	control qubit
Qubit*	target qubit
double	alpha
double	beta
double	gamma
double	delta

Returns:

QPanda::QGate quantum gate

QGate QPanda::CU(Qubit*, Qubit*, QStat& matrix)

Construct a new quantum CU gate.

Parameters:

Qubit*	target qubit
Qubit*	control qubit
QStat	& matrix

Returns:

QPanda::QGate quantum gate

QGate QPanda::I(int qaddr)

Construct a new I gate.

Construct QGate by Qubit physics addr

Parameters:

int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::X(int qaddr)

Construct a new quantum X gate.

Parameters:

int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::X1(int qaddr)

Construct a new quantum X1 gate.

Parameters:

int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::RX(int qaddr, double angle)

Construct a new quantum RX gate.

Parameters:

int	qaddr target qubit phy addr
double	angle

Returns:

QPanda::QGate quantum gate

QGate QPanda::U1(int qaddr, double angle)

Construct a new quantum U1 gate.

Parameters:

int	qaddr target qubit phy addr
double	angle

Returns:

QPanda::QGate quantum gate

QGate QPanda::U2(int qaddr, double phi, double lambda)

Construct a new quantum U2 gate.

Parameters:

int	qaddr target qubit phy addr
double	phi
double	lambda

Returns:

QPanda::QGate quantum gate

QGate QPanda::U3(int qaddr, double theta, double phi, double lambda)

Construct a new quantum U3 gate.

Parameters:

int	qaddr target qubit phy addr
double	theta
double	phi
double	lambda

Returns:

QPanda::QGate quantum gate

QGate QPanda::Y(int qaddr)

Construct a new quantum Y gate.

Parameters:

int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::Y1(int qaddr)

Construct a new quantum Y1 gate.

Parameters:

int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::RY(int qaddr, double angle)

Construct a new quantum RY gate.

Parameters:

int	qaddr target qubit phy addr
double	angle target qubit

Returns:

QPanda::QGate quantum gate

QGate QPanda::Z(int qaddr)

Construct a new quantum Z gate.

Parameters:

int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::Z1(int qaddr)

Construct a new quantum Z1 gate.

Parameters:

int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::RZ(int qaddr, double angle)

Construct a new quantum RZ gate.

Parameters:

int	qaddr target qubit phy addr
double	angle

Returns:

QPanda::QGate quantum gate

QGate QPanda::RPhi(int qaddr, double angle, double phi)

Construct a new quantum RZPhi gate.

Parameters:

int	qaddr target qubit phy addr
double	angle
double	phi

Returns:

QPanda::QGate quantum gate

QGate QPanda::S(int qaddr)

Construct a new quantum S gate.

Parameters:

int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::T(int qaddr)

Construct a new quantum T gate.

Parameters:

int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::H(int qaddr)

Construct a new quantum H gate.

Parameters:

int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::ECHO(int qaddr)

Construct a new quantum ECHO gate; Only for 6 qubits online projects !

Parameters:

int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::BARRIER(int qaddr)

Construct a new quantum BARRIER gate; Only for 6 qubits online projects !

Parameters:

int	qaddr target qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::BARRIER(std::vector<int> qaddrs)

Construct a new quantum BARRIER gate; Only for 6 qubits online projects !

Parameters:

std::vector<int>

qaddrs all qubit phy addr

Returns:

QPanda::QGate quantum gate

QGate QPanda::CNOT(int control_qaddr, int target_qaddr)

Construct a new quantum CNOT gate.

Parameters:

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

Returns:

QPanda::QGate quantum gate

QGate QPanda::CZ(int control_qaddr, int target_qaddr)

Construct a new quantum CZ gate.

Parameters:

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

Returns:

QPanda::QGate quantum gate

QGate QPanda::iSWAP(int control_qaddr, int target_qaddr, double theta)

Construct a new quantum iSWAP gate.

Parameters:

int	qaddr control qubit phy addr
int	qaddr target qubit phy addr
double	theta

Returns:

QPanda::QGate quantum gate

QGate QPanda::CR(int control_qaddr, int target_qaddr, double theta)

Construct a new quantum CR gate.

Parameters:

int	qaddr control qubit phy addr
int	qaddr target qubit phy addr
double	theta

Returns:

QPanda::QGate quantum gate

QGate QPanda::SqiSWAP(int control_qaddr, int target_qaddr)

Construct a new quantum SqiSWAP gate.

Parameters:

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

Returns:

QPanda::QGate quantum gate

QGate QPanda::SWAP(int control_qaddr, int target_qaddr)

Construct a new quantum SWAP gate.

Parameters:

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

Returns:

QPanda::QGate quantum gate

QGate QPanda::U4(int qaddr, double alpha, double beta, double gamma, double delta)

Construct a new quantum U4 gate.

Parameters:

int	qaddr target qubit phy addr
double	alpha
double	beta
double	gamma
double	delta

Returns:

QPanda::QGate quantum gate

QGate QPanda::U4(int qaddr, QStat& matrix)

Construct a new quantum U4 gate.

Parameters:

int	qaddr target qubit phy addr
QStat&	matrix

Returns:

QPanda::QGate quantum gate

QGate QPanda::QDouble(int control_qaddr, int target_qaddr, QStat& matrix)

Construct a new quantum QDouble gate.

Parameters:

int	qaddr control qubit phy addr
int	qaddr target qubit phy addr
QStat	matrix

Returns:

QPanda::QGate quantum gate

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

Construct a new quantum CU gate.

Parameters:

int	qaddr control qubit phy addr
int	qaddr target qubit phy addr
double	alpha
double	beta
double	gamma
double	delta

Returns:

QPanda::QGate quantum gate

QGate QPanda::CU(int control_qaddr, int target_qaddr, QStat& matrix)

Construct a new quantum CU gate.

Parameters:

int	qaddr control qubit phy addr
int	qaddr target qubit phy addr
QStat	& matrix

Returns:

QPanda::QGate quantum gate

template <typename _Ty>
_Ty QPanda::deepCopy(_Ty& node)

deep copy interface for classess base on QNode

Parameters:

_Ty

& node

Returns:

_Ty

QProg QPanda::createEmptyQProg()

QPanda2 basic interface for creating a empty quantum program.

Returns:

QPanda::QProg quantum program

QReset QPanda::Reset(Qubit*)

QPanda2 basic interface for creating a quantum Reset node.

Parameters:

Qubit*

Qubit pointer

Returns:

QPanda::QReset quantum reset node

QReset QPanda::Reset(int qaddr)

QPanda2 basic interface for creating a quantum Reset node.

Parameters:

int	qubit phy addr

Returns:

QPanda::QReset quantum reset node

QuantumMachine

class QPanda::CBit

Overview

CBit abstract class. More…

#include <CBitFactory.h>

class CBit
{
public:
    // methods

    virtual bool getOccupancy() const = 0;
    virtual std::string getName() const = 0;
    virtual void setOccupancy(bool) = 0;
    virtual cbit_size_t getValue() const = 0;
    virtual void set_val(const cbit_size_t) = 0;
    virtual cbit_size_t get_addr() const = 0;
};

// direct descendants

class OriginCBit;

Detailed Documentation

CBit abstract class.

Methods

virtual bool getOccupancy() const = 0

get the occupancy status of this bit

Returns:

bool ture: occupancy

virtual std::string getName() const = 0

get the name of this bit

Returns:

std::string

virtual void setOccupancy(bool) = 0

set the occupancy status of this bit

Parameters:

bool	occupancy status

virtual cbit_size_t getValue() const = 0

get the value of this bit

Returns:

cbit_size_t

virtual void set_val(const cbit_size_t) = 0

set the value of this bit

Parameters:

cbit_size_t

value

virtual cbit_size_t get_addr() const = 0

get the addr of this bit

Returns:

cbit_size_t

class QPanda::CBitFactory

Overview

Factory for class CBit. More…

#include <CBitFactory.h>

class CBitFactory
{
public:
    // typedefs

    typedef std::function<CBit*(std::string)> name_constructor_t;
    typedef std::map<std::string, name_constructor_t> name_constructor_stack_t;

    // fields

    name_constructor_stack_t _CBit_Constructor;

    // methods

    static CBitFactory& GetFactoryInstance();

    void registerclass_name_(
        std::string&,
        name_constructor_t constructor
        );

    CBit* CreateCBitFromName(std::string);
};

Detailed Documentation

Factory for class CBit.

Methods

static CBitFactory& GetFactoryInstance()

Get the static instance of factory.

Returns:

CBitFactory &

class QPanda::CBitFactoryHelper

CBit factory helper Provide CBitFactory class registration interface for the outside.

#include <CBitFactory.h>

class CBitFactoryHelper
{
public:
    // construction

    CBitFactoryHelper(
        std::string,
        name_constructor_t
        );
};

class QPanda::CMem

Overview

CMem abstract class, this class is considered as the container of the CBit. More…

#include <CMemFactory.h>

class CMem
{
public:
    // methods

    virtual CBit* Allocate_CBit() = 0;
    virtual CBit* Allocate_CBit(size_t) = 0;
    virtual size_t getMaxMem() const = 0;
    virtual size_t getIdleMem() const = 0;
    virtual void Free_CBit(CBit*) = 0;
    virtual void clearAll() = 0;
    virtual size_t get_allocate_cbits(std::vector<CBit*>&) = 0;
};

// direct descendants

class OriginCMem;
class OriginCMemv2;

Detailed Documentation

CMem abstract class, this class is considered as the container of the CBit.

Methods

virtual CBit* Allocate_CBit() = 0

allocate a CBit

Returns:

CBit*

virtual CBit* Allocate_CBit(size_t) = 0

allocate a CBit by bit address

Returns:

CBit*

virtual size_t getMaxMem() const = 0

get size of the CBit vector

Returns:

size_t

virtual size_t getIdleMem() const = 0

get size of the idle position

Returns:

size_t

virtual void Free_CBit(CBit*) = 0

free a CBit

Parameters:

CBit*

virtual void clearAll() = 0

clear the CBit vector

virtual size_t get_allocate_cbits(std::vector<CBit*>&) = 0

get allocate cbits

Parameters:

std::vector<CBit

*>&

Returns:

size_t allocate cbits size

class QPanda::CMemFactory

Overview

Factory for class CMem. More…

#include <CMemFactory.h>

class CMemFactory
{
public:
    // typedefs

    typedef std::function<CMem*(size_t)> size_constructor_t;
    typedef std::map<std::string, size_constructor_t> size_constructor_stack_t;

    // fields

    size_constructor_stack_t _CMem_Constructor;

    // methods

    CMem* GetInstanceFromSize(size_t);

    void registerclass_size_(
        std::string&,
        size_constructor_t
        );

    static CMemFactory& GetFactoryInstance();
};

Detailed Documentation

Factory for class CMem.

Methods

static CMemFactory& GetFactoryInstance()

Get the static instance of factory.

Returns:

CMemFactory &

class QPanda::CMemFactoryHelper

CMem factory helper Provide CMemFactory class registration interface for the outside.

#include <CMemFactory.h>

class CMemFactoryHelper
{
public:
    // construction

    CMemFactoryHelper(
        std::string,
        size_constructor_t _Constructor
        );
};

class QPanda::OriginCBit

Overview

Implementation class of CBit. More…

#include <OriginQuantumMachine.h>

class OriginCBit: public QPanda::CBit
{
public:
    // construction

    OriginCBit(std::string name);

    // methods

    virtual bool getOccupancy() const;
    virtual void setOccupancy(bool);
    virtual std::string getName() const;
    virtual cbit_size_t getValue() const;
    virtual void set_val(const cbit_size_t cbit_size_t);
    virtual cbit_size_t get_addr() const;
};

Inherited Members

public:
    // methods

    virtual bool getOccupancy() const = 0;
    virtual std::string getName() const = 0;
    virtual void setOccupancy(bool) = 0;
    virtual cbit_size_t getValue() const = 0;
    virtual void set_val(const cbit_size_t) = 0;
    virtual cbit_size_t get_addr() const = 0;

Detailed Documentation

Implementation class of CBit.

Methods

virtual bool getOccupancy() const

get the occupancy status of this bit

Returns:

bool ture: occupancy

virtual void setOccupancy(bool)

set the occupancy status of this bit

Parameters:

bool	occupancy status

virtual std::string getName() const

get the name of this bit

Returns:

std::string

virtual cbit_size_t getValue() const

get the value of this bit

Returns:

cbit_size_t

virtual void set_val(const cbit_size_t cbit_size_t)

set the value of this bit

Parameters:

cbit_size_t

value

virtual cbit_size_t get_addr() const

get the addr of this bit

Returns:

cbit_size_t

class QPanda::OriginCMem

Overview

Implementation class of CMem. More…

#include <OriginQuantumMachine.h>

class OriginCMem: public QPanda::CMem
{
public:
    // methods

    static OriginCMem* get_instance();
    CBit* get_cbit_by_addr(size_t caddr);
    size_t get_capacity();
    void set_capacity(size_t capacity_num);
    virtual CBit* Allocate_CBit();
    virtual CBit* Allocate_CBit(size_t);
    virtual size_t getMaxMem() const;
    virtual size_t getIdleMem() const;
    virtual void Free_CBit(CBit*);
    virtual void clearAll();
    virtual size_t get_allocate_cbits(std::vector<CBit*>&);
    CBit* cAlloc();
    CBit* cAlloc(size_t);
    std::vector<ClassicalCondition> cAllocMany(size_t);
    void cFree(CBit*);
    void cFreeAll(std::vector<CBit*>&);
};

Inherited Members

public:
    // methods

    virtual CBit* Allocate_CBit() = 0;
    virtual CBit* Allocate_CBit(size_t) = 0;
    virtual size_t getMaxMem() const = 0;
    virtual size_t getIdleMem() const = 0;
    virtual void Free_CBit(CBit*) = 0;
    virtual void clearAll() = 0;
    virtual size_t get_allocate_cbits(std::vector<CBit*>&) = 0;

Detailed Documentation

Implementation class of CMem.

Methods

virtual CBit* Allocate_CBit()

allocate a CBit

Returns:

CBit*

virtual CBit* Allocate_CBit(size_t)

allocate a CBit by bit address

Returns:

CBit*

virtual size_t getMaxMem() const

get size of the CBit vector

Returns:

size_t

virtual size_t getIdleMem() const

get size of the idle position

Returns:

size_t

virtual void Free_CBit(CBit*)

free a CBit

Parameters:

CBit*

virtual void clearAll()

clear the CBit vector

virtual size_t get_allocate_cbits(std::vector<CBit*>&)

get allocate cbits

Parameters:

std::vector<CBit

*>&

Returns:

size_t allocate cbits size

class QPanda::OriginPhysicalQubit

Overview

Implementation class of PhysicalQubit. More…

#include <OriginQuantumMachine.h>

class OriginPhysicalQubit: public QPanda::PhysicalQubit
{
public:
    // methods

    virtual size_t getQubitAddr();
    virtual void setQubitAddr(size_t);
    virtual bool getOccupancy() const;
    virtual void setOccupancy(bool);
};

Inherited Members

public:
    // methods

    virtual size_t getQubitAddr() = 0;
    virtual void setQubitAddr(size_t) = 0;
    virtual bool getOccupancy() const = 0;
    virtual void setOccupancy(bool) = 0;

Detailed Documentation

Implementation class of PhysicalQubit.

Methods

virtual size_t getQubitAddr()

get qubit address

Returns:

size_t

virtual void setQubitAddr(size_t)

set qubit address

Parameters:

size_t

qubit address

virtual bool getOccupancy() const

get the occupancy status of this qubit

Returns:

bool ture: occupancy

virtual void setOccupancy(bool)

set the occupancy status of this qubit

Parameters:

bool	occupancy status

class QPanda::OriginQMachineStatus

Implementation class of QMachineStatus.

#include <OriginQuantumMachine.h>

class OriginQMachineStatus: public QPanda::QMachineStatus
{
public:
    // methods

    virtual int getStatusCode() const;
    virtual void setStatusCode(int miStatus);
};

Inherited Members

public:
    // methods

    virtual int getStatusCode() const = 0;
    virtual void setStatusCode(int) = 0;

class QPanda::OriginQResult

Implementation class of QResult.

#include <OriginQuantumMachine.h>

class OriginQResult: public QPanda::QResult
{
public:
    // methods

    virtual std::map<std::string, bool> getResultMap() const;
    virtual void append(std::pair<std::string, bool>);
};

Inherited Members

public:
    // methods

    virtual std::map<std::string, bool> getResultMap() const = 0;
    virtual void append(std::pair<std::string, bool>) = 0;

class QPanda::OriginQubit

Overview

Implementation class of Qubit. More…

#include <OriginQuantumMachine.h>

class OriginQubit: public QPanda::Qubit
{
public:
    // construction

    OriginQubit(PhysicalQubit*);

    // methods

    virtual PhysicalQubit* getPhysicalQubitPtr() const;
    virtual bool getOccupancy();
};

Inherited Members

public:
    // methods

    virtual PhysicalQubit* getPhysicalQubitPtr() const = 0;
    virtual size_t get_phy_addr() const;
    virtual bool getOccupancy() = 0;

Detailed Documentation

Implementation class of Qubit.

Methods

virtual PhysicalQubit* getPhysicalQubitPtr() const

Get physical qubit pointer.

Returns:

PhysicalQubit *

virtual bool getOccupancy()

get the occupancy status of this qubit

Returns:

PhysicalQubit *

class QPanda::OriginQubitPoolv1

Overview

Implementation class of QubitPool. More…

#include <OriginQuantumMachine.h>

class OriginQubitPoolv1: public QPanda::QubitPool
{
public:
    // construction

    OriginQubitPoolv1(size_t maxQubit);

    // methods

    virtual void clearAll();
    virtual size_t getMaxQubit() const;
    virtual size_t getIdleQubit() const;
    virtual size_t get_max_usedqubit_addr() const;
    virtual Qubit* allocateQubit();
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t qubit_num);
    virtual void Free_Qubit(Qubit*);
    virtual size_t getPhysicalQubitAddr(Qubit*);
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual size_t get_allocate_qubits(std::vector<Qubit*>&) const;
};

Inherited Members

public:
    // methods

    virtual size_t getMaxQubit() const = 0;
    virtual size_t get_max_usedqubit_addr() const = 0;
    virtual size_t getIdleQubit() const = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t qubit_num) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void clearAll() = 0;
    virtual size_t getPhysicalQubitAddr(Qubit*) = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual size_t get_allocate_qubits(std::vector<Qubit*>&) const = 0;

Detailed Documentation

Implementation class of QubitPool.

Methods

virtual void clearAll()

clear the PhysicalQubit vector

virtual size_t getMaxQubit() const

get size of the PhysicalQubit vector

Returns:

size_t

virtual size_t getIdleQubit() const

get size of the idle position

Returns:

size_t

virtual size_t get_max_usedqubit_addr() const

Gets the largest address in the used physical qubit.

Returns:

size_t

virtual Qubit* allocateQubit()

allocate a Qubit

Returns:

Qubit*

virtual Qubit* allocateQubitThroughPhyAddress(size_t)

allocate a Qubit through physical address

Returns:

Qubit*

virtual Qubit* allocateQubitThroughVirAddress(size_t qubit_num)

allocate a Qubit through virtual address

Returns:

Qubit*

virtual void Free_Qubit(Qubit*)

free a Qubit

virtual size_t getPhysicalQubitAddr(Qubit*)

get physical qubit address

Parameters:

Qubit*

Returns:

size_t

virtual size_t getVirtualQubitAddress(Qubit*) const

get virtual qubit address

Parameters:

Qubit*

Returns:

size_t

virtual size_t get_allocate_qubits(std::vector<Qubit*>&) const

get allocate qubits

Parameters:

QVec&

Returns:

size_t

class QPanda::OriginQubitPoolv2

Overview

Implementation class of QubitPool. More…

#include <OriginQuantumMachine.h>

class OriginQubitPoolv2: public QPanda::QubitPool
{
public:
    // construction

    OriginQubitPoolv2(size_t maxQubit);

    // methods

    virtual void clearAll();
    virtual size_t getMaxQubit() const;
    virtual size_t getIdleQubit() const;
    virtual size_t get_max_usedqubit_addr() const;
    virtual Qubit* allocateQubit();
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t qubit_num);
    virtual void Free_Qubit(Qubit*);
    virtual size_t getPhysicalQubitAddr(Qubit*);
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual size_t get_allocate_qubits(std::vector<Qubit*>&) const;
};

Inherited Members

public:
    // methods

    virtual size_t getMaxQubit() const = 0;
    virtual size_t get_max_usedqubit_addr() const = 0;
    virtual size_t getIdleQubit() const = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t qubit_num) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void clearAll() = 0;
    virtual size_t getPhysicalQubitAddr(Qubit*) = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual size_t get_allocate_qubits(std::vector<Qubit*>&) const = 0;

Detailed Documentation

Implementation class of QubitPool.

Methods

virtual void clearAll()

clear the PhysicalQubit vector

virtual size_t getMaxQubit() const

get size of the PhysicalQubit vector

Returns:

size_t

virtual size_t getIdleQubit() const

get size of the idle position

Returns:

size_t

virtual size_t get_max_usedqubit_addr() const

Gets the largest address in the used physical qubit.

Returns:

size_t

virtual Qubit* allocateQubit()

allocate a Qubit

Returns:

Qubit*

virtual Qubit* allocateQubitThroughPhyAddress(size_t)

allocate a Qubit through physical address

Returns:

Qubit*

virtual Qubit* allocateQubitThroughVirAddress(size_t qubit_num)

allocate a Qubit through virtual address

Returns:

Qubit*

virtual void Free_Qubit(Qubit*)

free a Qubit

virtual size_t getPhysicalQubitAddr(Qubit*)

get physical qubit address

Parameters:

Qubit*

Returns:

size_t

virtual size_t getVirtualQubitAddress(Qubit*) const

get virtual qubit address

Parameters:

Qubit*

Returns:

size_t

virtual size_t get_allocate_qubits(std::vector<Qubit*>&) const

get allocate qubits

Parameters:

QVec&

Returns:

size_t

class QPanda::PartialAmplitudeQVM

Overview

Quantum machine for partial amplitude simulation. More…

#include <PartialAmplitudeQVM.h>

class PartialAmplitudeQVM:
    public QPanda::QVM,
    private QPanda::TraversalInterface
{
public:
    // fields

    PartialAmplitudeGraph m_graph_backend;

    // methods

    virtual void init();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);

    template <typename _Ty>
    void run(_Ty& node);

    qcomplex_t PMeasure_bin_index(std::string);
    qcomplex_t PMeasure_dec_index(std::string);
    stat_map PMeasure_subset(const std::vector<std::string>&);
    prob_dict getProbDict(const QVec&);

    prob_dict probRunDict(
        QProg& prog,
        const QVec&
        );

    virtual prob_vec getProbList(const QVec&);

    prob_vec probRunList(
        QProg&,
        const QVec&
        );

    void execute(
        std::shared_ptr<AbstractQGateNode>,
        std::shared_ptr<QNode>
        );

    void execute(
        std::shared_ptr<AbstractClassicalProg>,
        std::shared_ptr<QNode>
        );

    void execute(
        std::shared_ptr<AbstractQuantumMeasure>,
        std::shared_ptr<QNode>
        );

    void execute(
        std::shared_ptr<AbstractQuantumReset>,
        std::shared_ptr<QNode>
        );

    void execute(
        std::shared_ptr<AbstractQuantumCircuit>,
        std::shared_ptr<QNode>
        );

    void execute(
        std::shared_ptr<AbstractQuantumProgram>,
        std::shared_ptr<QNode>
        );

    void execute(
        std::shared_ptr<AbstractControlFlowNode>,
        std::shared_ptr<QNode>
        );
};

Inherited Members

public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {}) = 0;
    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {});
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t);
    virtual QMachineStatus* getStatus() const;
    virtual QResult* getResult();
    virtual std::map<std::string, bool> getResultMap();
    virtual void finalize();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<int>&, int);
    virtual std::map<GateType, size_t> getGateTimeMap() const;
    virtual QStat getQState() const;
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*);
    virtual void set_random_engine(RandomEngine* rng);
    virtual void setConfig(const Configuration& config);
    virtual Qubit* allocateQubit();
    virtual QVec allocateQubits(size_t);
    virtual ClassicalCondition allocateCBit();
    virtual std::vector<ClassicalCondition> allocateCBits(size_t);
    virtual ClassicalCondition allocateCBit(size_t);
    virtual size_t getAllocateQubit();
    virtual size_t getAllocateCMem();
    virtual void Free_Qubit(Qubit*);
    virtual void Free_Qubits(QVec&);
    virtual void Free_CBit(ClassicalCondition&);
    virtual void Free_CBits(std::vector<ClassicalCondition>&);
    virtual void setConfigure(const Configuration&);
    virtual Qubit* qAlloc();
    virtual QVec qAllocMany(size_t qubit_count);
    virtual ClassicalCondition cAlloc();
    virtual ClassicalCondition cAlloc(size_t);
    virtual std::vector<ClassicalCondition> cAllocMany(size_t);
    virtual void qFree(Qubit*);
    virtual void qFreeAll(QVec&);
    virtual void cFree(ClassicalCondition&);
    virtual void cFreeAll(std::vector<ClassicalCondition>&);
    virtual size_t getAllocateQubitNum();
    virtual size_t getAllocateCMemNum();
    virtual size_t get_allocate_qubits(QVec&);
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int);

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Quantum machine for partial amplitude simulation.

See also:

QuantumMachine

Methods

virtual void init()

init

Returns:

void

virtual std::map<std::string, bool> directlyRun(QProg& qProg)

directlyRun

Parameters:

QProg&

quantum program

Returns:

std::map<std::string, bool>

qcomplex_t PMeasure_bin_index(std::string)

PMeasure by binary index.

example: PMeasure_bin_index(“0000000000”)

Parameters:

std::string

binary index

Returns:

qstate_type double

qcomplex_t PMeasure_dec_index(std::string)

PMeasure by decimal index.

example: PMeasure_dec_index(“1”)

Parameters:

std::string

decimal index

Returns:

qstate_type double

stat_map PMeasure_subset(const std::vector<std::string>&)

PMeasure_subset.

output example: <0000000110:0.000167552>

Parameters:

QProg	qubits vec
std::vector<std::string>

Returns:

prob_map std::map<std::string, qstate_type>

class QPanda::PhysicalQubit

Overview

Physical Qubit abstract class. More…

#include <PhysicalQubitFactory.h>

class PhysicalQubit
{
public:
    // methods

    virtual size_t getQubitAddr() = 0;
    virtual void setQubitAddr(size_t) = 0;
    virtual bool getOccupancy() const = 0;
    virtual void setOccupancy(bool) = 0;
};

// direct descendants

class OriginPhysicalQubit;

Detailed Documentation

Physical Qubit abstract class.

Methods

virtual size_t getQubitAddr() = 0

get qubit address

Returns:

size_t

virtual void setQubitAddr(size_t) = 0

set qubit address

Parameters:

size_t

qubit address

virtual bool getOccupancy() const = 0

get the occupancy status of this qubit

Returns:

bool ture: occupancy

virtual void setOccupancy(bool) = 0

set the occupancy status of this qubit

Parameters:

bool	occupancy status

class QPanda::PhysicalQubitFactory

Overview

Factory for class PhysicalQubit. More…

#include <PhysicalQubitFactory.h>

class PhysicalQubitFactory
{
public:
    // typedefs

    typedef std::function<PhysicalQubit*()> constructor_t;
    typedef std::map<std::string, constructor_t> constructor_Map_t;

    // fields

    constructor_Map_t _Physical_Qubit_Constructor;

    // methods

    static PhysicalQubitFactory& GetFactoryInstance();
    PhysicalQubit* GetInstance();

    void registerclass(
        std::string&,
        constructor_t constructor
        );
};

Detailed Documentation

Factory for class PhysicalQubit.

Methods

static PhysicalQubitFactory& GetFactoryInstance()

Get the static instance of factory.

Returns:

PhysicalQubitFactory &

class QPanda::PhysicalQubitFactoryHelper

Physical Qubit Factory helper Provide PhysicalQubitFactory class registration interface for the outside.

#include <PhysicalQubitFactory.h>

class PhysicalQubitFactoryHelper
{
public:
    // construction

    PhysicalQubitFactoryHelper(
        std::string,
        constructor_t
        );
};

class QPanda::QMachineStatusFactory

Quantum Machine Status Factory.

#include <QuantumMachineFactory.h>

class QMachineStatusFactory
{
public:
    // methods

    static QMachineStatus* GetQMachineStatus();
};

class QPanda::QMachineTypeTarnfrom

Quantum machine type and name transformation.

#include <Factory.h>

class QMachineTypeTarnfrom
{
public:
    // methods

    static QMachineTypeTarnfrom& getInstance();
    std::string operator [] (QMachineType type);
    QMachineType operator [] (std::string gate_name);
};

class QPanda::QProgCheck

Overview

Qunatum QProgCheck. More…

#include <QProgCheck.h>

class QProgCheck
{
public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& paramu
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param
        );
};

Detailed Documentation

Qunatum QProgCheck.

Methods

virtual void execute(
    std::shared_ptr<AbstractQGateNode> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param
    )

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumMeasure> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param
    )

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumReset> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param
    )

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
QNode*	parent node
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractControlFlowNode> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param
    )

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumCircuit> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param
    )

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumProgram> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& paramu
    )

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractClassicalProg> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param
    )

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

class QPanda::QProgExecution

Overview

Qunatum Execution. More…

#include <QProgExecution.h>

class QProgExecution
{
public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param,
        QPUImpl* qpu
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param,
        QPUImpl* qpu
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param,
        QPUImpl* qpu
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param,
        QPUImpl* qpu
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param,
        QPUImpl* qpu
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param,
        QPUImpl* qpu
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        TraversalConfig& param,
        QPUImpl* qpu
        );

    void get_return_value(std::map<std::string, bool>& result);
};

Detailed Documentation

Qunatum Execution.

Methods

virtual void execute(
    std::shared_ptr<AbstractQGateNode> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param,
    QPUImpl* qpu
    )

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumMeasure> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param,
    QPUImpl* qpu
    )

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumReset> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param,
    QPUImpl* qpu
    )

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
QNode*	parent node
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractControlFlowNode> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param,
    QPUImpl* qpu
    )

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumCircuit> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param,
    QPUImpl* qpu
    )

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumProgram> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param,
    QPUImpl* qpu
    )

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractClassicalProg> cur_node,
    std::shared_ptr<QNode> parent_node,
    TraversalConfig& param,
    QPUImpl* qpu
    )

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate
TraversalConfig	traversal config
QPUImpl*	virtual quantum processor

Returns:

void

void get_return_value(std::map<std::string, bool>& result)

get result value

Parameters:

std::map<std::string
bool>	& result map

class QPanda::QResult

QResult abstract class, this class contains the result of the quantum measurement.

#include <QResultFactory.h>

class QResult
{
public:
    // methods

    virtual std::map<std::string, bool> getResultMap() const = 0;
    virtual void append(std::pair<std::string, bool>) = 0;
};

// direct descendants

class OriginQResult;

class QPanda::QResultFactory

Overview

Factory for class QResult. More…

#include <QResultFactory.h>

class QResultFactory
{
public:
    // typedefs

    typedef std::function<QResult*()> constructor_t;
    typedef std::map<std::string, constructor_t> constructor_Map_t;

    // fields

    constructor_Map_t _QResult_Constructor;

    // methods

    QResult* GetEmptyQResult();

    void registerclass(
        std::string&,
        constructor_t
        );

    static QResultFactory& GetFactoryInstance();
};

Detailed Documentation

Factory for class QResult.

Methods

static QResultFactory& GetFactoryInstance()

Get the static instance of factory.

Returns:

QResultFactory &

class QPanda::QResultFactoryHelper

QResult Factory helper Provide QResultFactory class registration interface for the outside.

#include <QResultFactory.h>

class QResultFactoryHelper
{
public:
    // construction

    QResultFactoryHelper(
        std::string,
        constructor_t _Constructor
        );
};

class QPanda::QVec

Qubit vector basic class.

#include <QVec.h>

class QVec: public std::vector< Qubit * >
{
public:
    // construction

    QVec(
        BaseClass::iterator iter_begin,
        BaseClass::iterator iter_end
        );

    QVec(const std::initializer_list<Qubit*>& args);
    QVec();
    QVec(const QVec& old);
    QVec(Qubit* q);
    QVec(BaseClass& vector);

    // methods

    Qubit* operator [] (ClassicalCondition& classical_cond);
    Qubit* operator [] (size_t pos) const;
    reference operator [] (size_type _Pos);
    QVec& operator << (int);
    QVec operator + (QVec vec) const;
    QVec& operator += (QVec vec);
    QVec operator - (QVec vec) const;
    QVec& operator -= (QVec vec);
};

class QPanda::QuantumMachine

Overview

Abstract quantum machine base classes. More…

#include <QuantumMachineInterface.h>

class QuantumMachine
{
public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;

    virtual void initState(
        const QStat& state = {},
        const QVec& qlist = {}
        ) = 0;

    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;
};

// direct descendants

class QVM;

Detailed Documentation

Abstract quantum machine base classes.

Methods

virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0

allocateQubitThroughPhyAddress

Parameters:

size_t

address

Returns:

QPanda::Qubit * qubit

virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0

allocateQubitThroughVirAddress

Parameters:

size_t

address

Returns:

QPanda::Qubit * qubit

virtual void init() = 0

init

Returns:

void

virtual QMachineStatus* getStatus() const = 0

getStatus

Returns:

QPanda::QMachineStatus *

virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0

directlyRun

Parameters:

QProg&

quantum program

Returns:

std::map<std::string, bool>

virtual std::map<std::string, size_t> runWithConfiguration(
    QProg&,
    std::vector<ClassicalCondition>&,
    rapidjson::Document&
    ) = 0

runWithConfiguration

Parameters:

QProg&	quantum program
std::vector<ClassicalCondition>&
rapidjson::Document&

Returns:

std::map<std::string, Eigen::size_t>

virtual std::map<std::string, size_t> runWithConfiguration(
    QProg&,
    std::vector<ClassicalCondition>&,
    int
    ) = 0

runWithConfiguration

Parameters:

QProg&	quantum program
std::vector<ClassicalCondition>&
int

Returns:

std::map<std::string, Eigen::size_t>

virtual std::map<GateType, size_t> getGateTimeMap() const = 0

getGateTimeMap

Returns:

std::map<GateType, Eigen::size_t>

virtual void finalize() = 0

finalize

Returns:

void

virtual QStat getQState() const = 0

getQState

Returns:

QStat

virtual size_t getVirtualQubitAddress(Qubit*) const = 0

getVirtualQubitAddress

Parameters:

Qubit*

qubit

Returns:

Eigen::size_t

virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0

swapQubitPhysicalAddress

Parameters:

Qubit*	qubit
Qubit*	qubit

Returns:

bool

virtual Qubit* allocateQubit() = 0

To initialize the quantum machine.

virtual QVec allocateQubits(size_t) = 0

Allocate and return a qubit.

virtual ClassicalCondition allocateCBit() = 0

allocateQubits

virtual ClassicalCondition allocateCBit(size_t) = 0

Allocate and run a cbit.

virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0

Allocate and run a cbit.

virtual void Free_Qubit(Qubit*) = 0

Allocate and return a list of cbits.

virtual void Free_Qubits(QVec&) = 0

Free a qubit.

virtual void Free_CBit(ClassicalCondition&) = 0

Gree a list of qubits.

virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0

Gree a cbit.

virtual size_t getAllocateQubit() = 0

Gree a list of CBits.

virtual size_t getAllocateCMem() = 0

getAllocateQubit

virtual void setConfigure(const Configuration&) = 0

getAllocateCMem

setConfigure

Parameters:

const

Configuration & config

Returns:

void

virtual Qubit* qAlloc() = 0

qAlloc

Returns:

QPanda::Qubit * qubit

virtual QVec qAllocMany(size_t qubit_count) = 0

qAllocMany

Parameters:

size_t

qubit_count

Returns:

QPanda::QVec

virtual ClassicalCondition cAlloc() = 0

cAlloc

Returns:

QPanda::ClassicalCondition

virtual ClassicalCondition cAlloc(size_t) = 0

cAlloc

Parameters:

size_t

Returns:

QPanda::ClassicalCondition

virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0

cAllocMany

Parameters:

size_t

count

Returns:

std::vector<QPanda::ClassicalCondition> cbit_vec

virtual void qFree(Qubit*) = 0

qFree

Parameters:

Qubit*

Returns:

void

virtual void qFreeAll(QVec&) = 0

qFreeAll

Parameters:

QVec&

Returns:

void

virtual void cFree(ClassicalCondition&) = 0

cFree

Parameters:

ClassicalCondition&

cbit

Returns:

void

virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0

cFreeAll

Parameters:

std::vector<ClassicalCondition

>& cbit_vec

Returns:

void

virtual size_t getAllocateQubitNum() = 0

getAllocateQubitNum

Returns:

Eigen::size_t count

virtual size_t getAllocateCMemNum() = 0

getAllocateCMemNum

Returns:

Eigen::size_t count

virtual size_t get_allocate_qubits(QVec&) = 0

get allocate qubits

Parameters:

QVec&

Returns:

size_t allocate qubits size

virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0

get allocate cbits

Parameters:

std::vector<ClassicalCondition>&

Returns:

size_t allocate cbits size

virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0

gets the expected value of the Hamiltonian of the circuit

Parameters:

QProg	quantum program
QHamiltonian	hamiltonian
QVec	qubits

Returns:

double expectation

virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0

gets the expected value of the Hamiltonian of the circuit

Parameters:

QProg	quantum program
QHamiltonian	hamiltonian
QVec	qubits
int	run shots

Returns:

double expectation

class QPanda::QuantumMachineFactory

Overview

Factory for class QuantumMachine. More…

#include <QuantumMachineFactory.h>

class QuantumMachineFactory
{
public:
    // typedefs

    typedef std::function<QuantumMachine*()> constructor_t;
    typedef std::map<std::string, constructor_t> constructor_map_t;

    // fields

    constructor_map_t _Quantum_Machine_Constructor;

    // methods

    static QuantumMachineFactory& GetFactoryInstance();
    QuantumMachine* CreateByName(std::string);
    QuantumMachine* CreateByType(QMachineType class_type);

    void registerclass(
        std::string,
        constructor_t constructor
        );
};

Detailed Documentation

Factory for class QuantumMachine.

Methods

static QuantumMachineFactory& GetFactoryInstance()

Get the static instance of factory.

Returns:

QuantumMachineFactory &

class QPanda::QuantumMachineFactoryHelper

Quantum Machine Factory helper Provide QuantumMachineFactory class registration interface for the outside.

#include <QuantumMachineFactory.h>

class QuantumMachineFactoryHelper
{
public:
    // construction

    QuantumMachineFactoryHelper(
        std::string,
        constructor_t
        );
};

class QPanda::Qubit

Overview

Qubit abstract class. More…

#include <QubitFactory.h>

class Qubit
{
public:
    // methods

    virtual PhysicalQubit* getPhysicalQubitPtr() const = 0;
    virtual size_t get_phy_addr() const;
    virtual bool getOccupancy() = 0;
};

// direct descendants

class OriginQubit;
class QubitReference;

Detailed Documentation

Qubit abstract class.

Methods

virtual PhysicalQubit* getPhysicalQubitPtr() const = 0

Get physical qubit pointer.

Returns:

PhysicalQubit *

virtual size_t get_phy_addr() const

Get physical addr.

Returns:

size_t

virtual bool getOccupancy() = 0

get the occupancy status of this qubit

Returns:

PhysicalQubit *

class QPanda::QubitFactory

Overview

Factory for class Qubit. More…

#include <QubitFactory.h>

class QubitFactory
{
public:
    // typedefs

    typedef std::function<Qubit*(PhysicalQubit*)> constructor_t;
    typedef std::map<std::string, constructor_t> constructor_Map_t;

    // fields

    constructor_Map_t _Qubit_Constructor;

    // methods

    static QubitFactory& GetFactoryInstance();
    Qubit* GetInstance(PhysicalQubit*);

    void registerclass(
        std::string&,
        constructor_t constructor
        );
};

Detailed Documentation

Factory for class Qubit.

Methods

static QubitFactory& GetFactoryInstance()

Get the static instance of factory.

Returns:

QubitFactory &

class QPanda::QubitFactoryHelper

Qubit Factory helper Provide QubitFactory class registration interface for the outside.

#include <QubitFactory.h>

class QubitFactoryHelper
{
public:
    // construction

    QubitFactoryHelper(
        std::string,
        constructor_t
        );
};

class QPanda::QubitPool

Overview

QubitPool abstract class It is the container of the PhysicalQubit. More…

#include <QubitPoolFactory.h>

class QubitPool
{
public:
    // methods

    virtual size_t getMaxQubit() const = 0;
    virtual size_t get_max_usedqubit_addr() const = 0;
    virtual size_t getIdleQubit() const = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t qubit_num) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void clearAll() = 0;
    virtual size_t getPhysicalQubitAddr(Qubit*) = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual size_t get_allocate_qubits(std::vector<Qubit*>&) const = 0;
};

// direct descendants

class OriginQubitPool;
class OriginQubitPoolv1;
class OriginQubitPoolv2;

Detailed Documentation

QubitPool abstract class It is the container of the PhysicalQubit.

Methods

virtual size_t getMaxQubit() const = 0

get size of the PhysicalQubit vector

Returns:

size_t

virtual size_t get_max_usedqubit_addr() const = 0

Gets the largest address in the used physical qubit.

Returns:

size_t

virtual size_t getIdleQubit() const = 0

get size of the idle position

Returns:

size_t

virtual Qubit* allocateQubit() = 0

allocate a Qubit

Returns:

Qubit*

virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0

allocate a Qubit through physical address

Returns:

Qubit*

virtual Qubit* allocateQubitThroughVirAddress(size_t qubit_num) = 0

allocate a Qubit through virtual address

Returns:

Qubit*

virtual void Free_Qubit(Qubit*) = 0

free a Qubit

virtual void clearAll() = 0

clear the PhysicalQubit vector

virtual size_t getPhysicalQubitAddr(Qubit*) = 0

get physical qubit address

Parameters:

Qubit*

Returns:

size_t

virtual size_t getVirtualQubitAddress(Qubit*) const = 0

get virtual qubit address

Parameters:

Qubit*

Returns:

size_t

virtual size_t get_allocate_qubits(std::vector<Qubit*>&) const = 0

get allocate qubits

Parameters:

QVec&

Returns:

size_t

class QPanda::QubitPoolFactory

Overview

Factory for class QubitPool. More…

#include <QubitPoolFactory.h>

class QubitPoolFactory
{
public:
    // typedefs

    typedef std::function<QubitPool*(size_t)> size_constructor_t;
    typedef std::map<std::string, size_constructor_t> size_constructor_stack_t;

    // fields

    size_constructor_stack_t _Qubit_Pool_Constructor;

    // methods

    static QubitPoolFactory& GetFactoryInstance();
    QubitPool* GetPoolWithoutTopology(size_t);

    void registerclass_size_(
        std::string&,
        size_constructor_t constructor
        );
};

Detailed Documentation

Factory for class QubitPool.

Methods

static QubitPoolFactory& GetFactoryInstance()

Get the static instance of factory.

Returns:

QubitPoolFactory &

class QPanda::QubitPoolFactoryHelper

Qubit Pool Factory helper Provide QubitPoolFactory class registration interface for the outside.

#include <QubitPoolFactory.h>

class QubitPoolFactoryHelper
{
public:
    // construction

    QubitPoolFactoryHelper(
        std::string,
        size_constructor_t
        );
};

class QPanda::QubitReference

Overview

The position of the qubit is an expression. More…

#include <QubitReference.h>

class QubitReference:
    public QPanda::Qubit,
    public QPanda::QubitReferenceInterface
{
public:
    // construction

    QubitReference(
        ClassicalCondition& cc,
        std::vector<Qubit*> qvec
        );

    QubitReference(const QubitReference& old);

    // methods

    virtual PhysicalQubit* getPhysicalQubitPtr() const;
    virtual bool getOccupancy();
    virtual std::shared_ptr<CExpr> getExprPtr();
};

Inherited Members

public:
    // methods

    virtual PhysicalQubit* getPhysicalQubitPtr() const = 0;
    virtual size_t get_phy_addr() const;
    virtual bool getOccupancy() = 0;
    virtual std::shared_ptr<CExpr> getExprPtr() = 0;

Detailed Documentation

The position of the qubit is an expression.

Methods

virtual PhysicalQubit* getPhysicalQubitPtr() const

Get physical qubit pointer.

Returns:

PhysicalQubit *

virtual bool getOccupancy()

get the occupancy status of this qubit

Returns:

PhysicalQubit *

class QPanda::QubitReferenceInterface

QubitReferenceInterface abstract class.

#include <QubitFactory.h>

class QubitReferenceInterface
{
public:
    // methods

    virtual std::shared_ptr<CExpr> getExprPtr() = 0;
};

// direct descendants

class QubitReference;

class QPanda::SingleAmplitudeQVM

Overview

Quantum machine for single amplitude simulation. More…

#include <SingleAmplitudeQVM.h>

class SingleAmplitudeQVM:
    public QPanda::QVM,
    public QPanda::TraversalInterface
{
public:
    // methods

    virtual void init();
    void run(QProg& prog, QVec& qv, size_t max_rank = 30, size_t alloted_time = 5);
    void run(QProg& prog, QVec& qv, size_t max_rank, const std::vector<qprog_sequence_t>& sequences);
    size_t getSequence(const std::vector<size_t>& quickbb_vertice, std::vector<qprog_sequence_t>& sequence_vec);
    void getQuickMapVertice(std::vector<std::pair<size_t, size_t>>& map_vector);
    qstate_type pMeasureBinindex(std::string index);
    qstate_type pMeasureDecindex(std::string index);
    prob_dict getProbDict(QVec qlist);
    prob_dict probRunDict(QProg& prog, QVec qlist);
    prob_dict getProbDict(const std::vector<int>& qaddrs_list);

    prob_dict probRunDict(
        QProg& prog,
        const std::vector<int>& qaddrs_list
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool& is_dagger
        );
};

Inherited Members

public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {}) = 0;
    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {});
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t);
    virtual QMachineStatus* getStatus() const;
    virtual QResult* getResult();
    virtual std::map<std::string, bool> getResultMap();
    virtual void finalize();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<int>&, int);
    virtual std::map<GateType, size_t> getGateTimeMap() const;
    virtual QStat getQState() const;
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*);
    virtual void set_random_engine(RandomEngine* rng);
    virtual void setConfig(const Configuration& config);
    virtual Qubit* allocateQubit();
    virtual QVec allocateQubits(size_t);
    virtual ClassicalCondition allocateCBit();
    virtual std::vector<ClassicalCondition> allocateCBits(size_t);
    virtual ClassicalCondition allocateCBit(size_t);
    virtual size_t getAllocateQubit();
    virtual size_t getAllocateCMem();
    virtual void Free_Qubit(Qubit*);
    virtual void Free_Qubits(QVec&);
    virtual void Free_CBit(ClassicalCondition&);
    virtual void Free_CBits(std::vector<ClassicalCondition>&);
    virtual void setConfigure(const Configuration&);
    virtual Qubit* qAlloc();
    virtual QVec qAllocMany(size_t qubit_count);
    virtual ClassicalCondition cAlloc();
    virtual ClassicalCondition cAlloc(size_t);
    virtual std::vector<ClassicalCondition> cAllocMany(size_t);
    virtual void qFree(Qubit*);
    virtual void qFreeAll(QVec&);
    virtual void cFree(ClassicalCondition&);
    virtual void cFreeAll(std::vector<ClassicalCondition>&);
    virtual size_t getAllocateQubitNum();
    virtual size_t getAllocateCMemNum();
    virtual size_t get_allocate_qubits(QVec&);
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int);

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Quantum machine for single amplitude simulation.

See also:

QuantumMachine

Methods

virtual void init()

init

Returns:

void

void run(QProg& prog, QVec& qv, size_t max_rank = 30, size_t alloted_time = 5)

run

Parameters:

QProg&	quantum program
QVec&	qubits vector
size_t	rank number
size_t	run QuickBB alloted time

void run(QProg& prog, QVec& qv, size_t max_rank, const std::vector<qprog_sequence_t>& sequences)

run

Parameters:

QProg&	quantum program
QVec&	qubits vector
size_t	rank number
size_t	quantum program contraction sequence

size_t getSequence(
    const std::vector<size_t>& quickbb_vertice,
    std::vector<qprog_sequence_t>& sequence_vec
    )

get quantum program contraction sequence

Parameters:

const	std::vector<size_t>& quickbb vertice
std::vector<qprog_sequence_t>&	quantum program contraction sequence

Returns:

size_t sequence number

qstate_type pMeasureBinindex(std::string index)

PMeasure by binary index.

example: pMeasureBinindex(“0000000000”)

Parameters:

std::string

binary index

Returns:

qstate_type double

qstate_type pMeasureDecindex(std::string index)

PMeasure by decimal index.

example: pMeasureDecindex(“1”)

Parameters:

std::string

decimal index

Returns:

qstate_type double

prob_dict getProbDict(QVec qlist)

get probability by qubits

Parameters:

const

QVec & qubits vector

Returns:

prob_dict

prob_dict probRunDict(QProg& prog, QVec qlist)

get probability by qubits

Parameters:

QProg&	quantum program
QVec&	qubits vector

Returns:

prob_dict

Overview

QPanda2 quantum virtual machine. More…

// classes

class QPanda::CBit;
class QPanda::CBitFactory;
class QPanda::CBitFactoryHelper;
class QPanda::CMem;
class QPanda::CMemFactory;
class QPanda::CMemFactoryHelper;
class QPanda::OriginCBit;
class QPanda::OriginCMem;
class QPanda::OriginPhysicalQubit;
class QPanda::OriginQMachineStatus;
class QPanda::OriginQResult;
class QPanda::OriginQubit;
class QPanda::OriginQubitPoolv1;
class QPanda::OriginQubitPoolv2;
class QPanda::PartialAmplitudeQVM;
class QPanda::PhysicalQubit;
class QPanda::PhysicalQubitFactory;
class QPanda::PhysicalQubitFactoryHelper;
class QPanda::QMachineStatusFactory;
class QPanda::QMachineTypeTarnfrom;
class QPanda::QProgCheck;
class QPanda::QProgExecution;
class QPanda::QResult;
class QPanda::QResultFactory;
class QPanda::QResultFactoryHelper;
class QPanda::QVec;
class QPanda::QuantumMachine;
class QPanda::QuantumMachineFactory;
class QPanda::QuantumMachineFactoryHelper;
class QPanda::Qubit;
class QPanda::QubitFactory;
class QPanda::QubitFactoryHelper;
class QPanda::QubitPool;
class QPanda::QubitPoolFactory;
class QPanda::QubitPoolFactoryHelper;
class QPanda::QubitReference;
class QPanda::QubitReferenceInterface;
class QPanda::SingleAmplitudeQVM;

// global functions

void QPanda::execute_qprog(QProg prog, QPUImpl* qpu, TraversalConfig& param);

Detailed Documentation

QPanda2 quantum virtual machine.

Global Functions

void QPanda::execute_qprog(QProg prog, QPUImpl* qpu, TraversalConfig& param)

execute qprog

Parameters:

QProg	quantum program
QPUImpl*
TraversalConfig&	traversal configuration

Returns:

Utilities

struct QPanda::CallGateInfo

define QGate function info

#include <OriginIRToQProg.h>

struct CallGateInfo
{
    // fields

    std::string gate_name;
    std::vector<std::string> qubits;
    std::vector<std::shared_ptr<Exp>> angles;
};

struct QPanda::KakDescription

Kak description of an arbitrary two-qubit operation. U = g x (Gate A1 Gate A0) x exp(i(xXX + yYY + zZZ))x(Gate b1 Gate b0) A global phase factor Two single-qubit operations (before): Gate b0, b1 The Exp() circuit specified by 3 coefficients (x, y, z) Two single-qubit operations (after): Gate a0, a1.

#include <KAK.h>

struct KakDescription
{
    // fields

    Eigen::Matrix4cd in_matrix;
    std::complex<double> global_phase;
    Eigen::Matrix2cd b0;
    Eigen::Matrix2cd b1;
    Eigen::Matrix2cd a0;
    Eigen::Matrix2cd a1;
    double x;
    double y;
    double z;

    // methods

    QCircuit to_qcircuit(
        Qubit* in_bit1,
        Qubit* in_bit2
        ) const;

    Eigen::MatrixXcd to_matrix() const;
};

class QPanda::AdjacentQGates

class QPanda::AdjacentQGates::AbstractTraversalStatueInterface

class AbstractTraversalStatueInterface
{
public:
    // methods

    virtual void handle_QGate(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void handle_QMeasure(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void handle_QReset(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void on_enter_QIf(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void on_leave_QIf(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void on_enter_QWhile(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void on_leave_QWhile(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void handle_classical_prog(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual TraversalStatue get_statue() const = 0;
};

class QPanda::AdjacentQGates::FoundAllAdjacentNode

class FoundAllAdjacentNode: public QPanda::AdjacentQGates::AbstractTraversalStatueInterface
{
public:
    // construction

    FoundAllAdjacentNode(
        AdjacentQGates& parent,
        TraversalStatue s
        );

    // methods

    TraversalStatue get_statue() const;
};

class QPanda::AdjacentQGates::HaveNotFoundTargetNode

class HaveNotFoundTargetNode: public QPanda::AdjacentQGates::AbstractTraversalStatueInterface
{
public:
    // construction

    HaveNotFoundTargetNode(
        AdjacentQGates& parent,
        TraversalStatue s
        );

    // methods

    void handle_QGate(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void handle_QMeasure(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void handle_QReset(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void on_enter_QIf(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void on_leave_QIf(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void on_enter_QWhile(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void on_leave_QWhile(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void handle_classical_prog(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    TraversalStatue get_statue() const;
};

class QPanda::AdjacentQGates::ToFindBackNode

class ToFindBackNode: public QPanda::AdjacentQGates::AbstractTraversalStatueInterface
{
public:
    // construction

    ToFindBackNode(
        AdjacentQGates& parent,
        TraversalStatue s
        );

    // methods

    void handle_QGate(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void handle_QMeasure(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void handle_QReset(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void on_enter_QIf(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void on_leave_QIf(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void on_enter_QWhile(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void on_leave_QWhile(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void handle_classical_prog(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    TraversalStatue get_statue() const;
};

Get information about adjacent nodes.

#include <GetAdjacentNodes.h>

class AdjacentQGates: public QPanda::TraverseByNodeIter
{
public:
    // classes

    class AbstractTraversalStatueInterface;
    class FoundAllAdjacentNode;
    class HaveNotFoundTargetNode;
    class ToFindBackNode;

    // construction

    AdjacentQGates(
        QProg prog,
        NodeIter& nodeItr
        );

    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog();

    void update_front_iter(
        const NodeIter& itr,
        const QCircuitParam& cir_param
        );

    void update_back_iter(
        const NodeIter& itr,
        const QCircuitParam& cir_param
        );

    GateType get_node_ype(const NodeIter& ter);
    std::string get_node_type_str(const NodeIter& ter);
    std::string get_back_node_type_str();
    std::string get_front_node_type_str();
    bool is_valid_node_type(const NodeIter& itr);
    bool is_valid_node_type(const NodeType t);
    const NodeInfo& get_front_node();
    const NodeInfo& get_back_node();
    void change_traversal_statue(AbstractTraversalStatueInterface* s);
    static bool is_sub_prog_node(const std::shared_ptr<QNode>& node);
    static bool is_flow_ctrl_node(const std::shared_ptr<QNode>& node);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);

class QPanda::BasicGridDevice

struct QPanda::BasicGridDevice::PhysicalQubit

Overview

#include <GridDevice.h>

struct PhysicalQubit
{
    // fields

    int map_to = -1;
    int time;
    std::vector<std::pair<int, int>> nearbyQubits;
};

Detailed Documentation

Fields

int map_to = -1

which logical qubit maps to it, -1 if no

int time

time when it become free again, the qubit lock

Overview

A BasicGirdDevice is a device model that qubits put on nodes of a rectangular grid It is a virtual class because we haven’t dicided how qubits connecting with each other For the simpliest situation, see SimpleGridDevice. More…

#include <GridDevice.h>

class BasicGridDevice
{
public:
    // structs

    struct PhysicalQubit;

    // construction

    BasicGridDevice(int m, int n);

    // methods

    void clear();
    int getM();
    int getN();
    auto& getQubit(int i, int j);
    bool canApplyGate(int i1, int j1, int i2, int j2, int);
    bool canApplyGate(int i, int j, int);

    bool canSwap(
        int i1,
        int j1,
        int i2,
        int j2
        );

    void applySingleGate(int i, int j);
    void applyGate(int i1, int j1, int i2, int j2, int time);

    void applyDoubleGate(
        int i1,
        int j1,
        int i2,
        int j2
        );

    void applySwap(
        int i1,
        int j1,
        int i2,
        int j2
        );

    virtual bool isNearBy(int i1, int j1, int i2, int j2) = 0;
    virtual int getDistance(int i1, int j1, int i2, int j2) = 0;
    void map(int dest, int i, int j);
    void resetTime();
    void nextCycle();
    int maxTime();
    int getTime();
    bool isQubitFree(int i, int j);
    bool isAllQubitFree();
    bool isSimpleGridDevice();
    bool isSupportSwapGate();
};

// direct descendants

class ExGridDevice;
class SimpleGridDevice;

Detailed Documentation

A BasicGirdDevice is a device model that qubits put on nodes of a rectangular grid It is a virtual class because we haven’t dicided how qubits connecting with each other For the simpliest situation, see SimpleGridDevice.

Construction

BasicGridDevice(int m, int n)

constructor constructor

m, n: the grid side length

Methods

void clear()

clear all properties except gird side length, re-initialize

auto& getQubit(int i, int j)

get the qubit on (i, j)

bool canApplyGate(int i1, int j1, int i2, int j2, int)

Determine whether a double-qubit gate can be applied.

bool canApplyGate(int i, int j, int)

Determine whether a single-qubit gate can be applied.

void applySingleGate(int i, int j)

apply gate and comsume time

void applyGate(int i1, int j1, int i2, int j2, int time)

apply a double-qubit gate

virtual bool isNearBy(int i1, int j1, int i2, int j2) = 0

Check if two qubits are adjacent, location of qubits are (i1, j1) and (i2, j2)

virtual int getDistance(int i1, int j1, int i2, int j2) = 0

get distance+1 of two qubits

void map(int dest, int i, int j)

map one qubit

Parameters:

int	dest: index of the logical qubit
int	i: location of the physical qubit
int	j: location of the physical qubit

void resetTime()

reset the time

void nextCycle()

go on next instruction cycle

int maxTime()

time when all qubits end up being busy

bool isQubitFree(int i, int j)

check if physical qubit on (i, j) free

bool isAllQubitFree()

check if all physical qubits free

class QPanda::CancelControlQubitVector

Overview

Cancel control qubit vector in qprog. More…

#include <TransformDecomposition.h>

class CancelControlQubitVector: public QPanda::TraversalInterface
{
public:
    // methods

    void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node);
    void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Cancel control qubit vector in qprog.

Methods

void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class QPanda::ConfigMap

Configuration Map.

#include <ConfigMap.h>

class ConfigMap
{
public:
    // methods

    static ConfigMap& getInstance();
    std::string operator [] (const char*);
};

class QPanda::CrossEntropyBenchmarking

Overview

use cross entropy benchmarking (XEB) to calibrate general single- and two-qubit gates More…

#include <CrossEntropyBenchmarking.h>

class CrossEntropyBenchmarking
{
public:
    // typedefs

    typedef std::vector<std::vector<std::vector<double>>> ProbsDict;

    // construction

    CrossEntropyBenchmarking(
        MeasureQVMType type,
        QuantumMachine* qvm
        );

    // methods

    std::map<int, double> calculate_xeb_fidelity(
        GateType gt,
        Qubit* qbit0,
        Qubit* qbit1,
        const std::vector<int>& cycle_range,
        int num_circuits,
        int shots
        );
};

Detailed Documentation

use cross entropy benchmarking (XEB) to calibrate general single- and two-qubit gates

Methods

std::map<int, double> calculate_xeb_fidelity(
    GateType gt,
    Qubit* qbit0,
    Qubit* qbit1,
    const std::vector<int>& cycle_range,
    int num_circuits,
    int shots
    )

calculate xeb fidelity

Parameters:

GateType	gate type for calculating fidelity, must be double gate
Qubit*	qubit0
Qubit*	qubit1 , Must be adjacent to qubit0
const	std::vector<int>& the size of each layer
int	number of circuits of each layer
int	measure shot number

Returns:

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

class QPanda::DecomposeControlUnitarySingleQGate

Overview

Decomposing control unitary single qgate in qprog. More…

#include <TransformDecomposition.h>

class DecomposeControlUnitarySingleQGate: public QPanda::TraversalInterface
{
public:
    // construction

    DecomposeControlUnitarySingleQGate(std::vector<std::vector<std::string>> valid_qgate_matrix);

    // methods

    void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Decomposing control unitary single qgate in qprog.

Methods

void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class QPanda::DecomposeDoubleQGate

Overview

Decomposing double gates in qprog. More…

#include <TransformDecomposition.h>

class DecomposeDoubleQGate: public QPanda::TraversalInterface
{
public:
    // construction

    DecomposeDoubleQGate(std::vector<std::vector<std::string>> valid_qgate_matrix);

    // methods

    virtual void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Decomposing double gates in qprog.

Decomposing control unitary single qgate in qprog.

Methods

virtual void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class QPanda::DecomposeMultipleControlQGate

Overview

Decomposing multiple control qgate in qprog. More…

#include <TransformDecomposition.h>

class DecomposeMultipleControlQGate: public QPanda::TraversalInterface
{
public:
    // methods

    void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node);
    void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Decomposing multiple control qgate in qprog.

Methods

void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class QPanda::DecomposeUnitarySingleQGateIntoMetadataSingleQGate

Overview

Decomposing unitary single qgate into metadata single qgate in qprog. More…

#include <TransformDecomposition.h>

class DecomposeUnitarySingleQGateIntoMetadataSingleQGate: public QPanda::TraversalInterface
{
public:
    // construction

    DecomposeUnitarySingleQGateIntoMetadataSingleQGate(
        std::vector<std::vector<std::string>> qgate_matrix,
        std::vector<std::vector<std::string>>& valid_qgate_matrix
        );

    // methods

    void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Decomposing unitary single qgate into metadata single qgate in qprog.

Methods

void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class DeleteUnitQnode

Decomposing unit qnode in qprog.

class QPanda::DoubleGateTypeValidator

Get double gate metadata Validator type.

#include <MetadataValidity.h>

class DoubleGateTypeValidator
{
public:
    // fields

    MetadataValidity m_metadata_validity_functions;

    // methods

    static int GateType(
        std::vector<std::string>& gates,
        std::vector<std::string>& valid_gates
        );
};

class QPanda::DRAW_TEXT_PIC::DrawQProg

Overview

draw Qprog by text More…

#include <DrawQProg.h>

class DrawQProg
{
public:
    // construction

    DrawQProg(
        QProg& prg,
        const NodeIter node_itr_start,
        const NodeIter node_itr_end,
        bool b_out_put_to_file = false
        );

    // methods

    std::string textDraw(TEXT_PIC_TYPE t, uint32_t length = 100, const std::string config_data = CONFIG_PATH);
};

Detailed Documentation

draw Qprog by text

Construction

DrawQProg(
    QProg& prg,
    const NodeIter node_itr_start,
    const NodeIter node_itr_end,
    bool b_out_put_to_file = false
    )

Constructor of DrawQProg.

Methods

std::string textDraw(
    TEXT_PIC_TYPE t,
    uint32_t length = 100,
    const std::string config_data = CONFIG_PATH
    )

Draw text-picture.

Parameters:

TEXT_PIC_TYPE	draw type
const	std::string It can be configuration file or configuration data, which can be distinguished by file suffix, so the configuration file must be end with “.json”, default is CONFIG_PATH

Returns:

std::string the text-picture

See also:

TEXT_PIC_TYPE

class QPanda::ExGridDevice

Overview

#include <GridDevice.h>

class ExGridDevice: public QPanda::BasicGridDevice
{
public:
    // construction

    ExGridDevice(int m, int n, std::vector<std::pair<int, int>>& qpairs);
};

Inherited Members

public:
    // structs

    struct PhysicalQubit;

    // methods

    void clear();
    int getM();
    int getN();
    auto& getQubit(int i, int j);
    bool canApplyGate(int i1, int j1, int i2, int j2, int);
    bool canApplyGate(int i, int j, int);
    bool canSwap(int i1, int j1, int i2, int j2);
    void applySingleGate(int i, int j);
    void applyGate(int i1, int j1, int i2, int j2, int time);
    void applyDoubleGate(int i1, int j1, int i2, int j2);
    void applySwap(int i1, int j1, int i2, int j2);
    virtual bool isNearBy(int i1, int j1, int i2, int j2) = 0;
    virtual int getDistance(int i1, int j1, int i2, int j2) = 0;
    void map(int dest, int i, int j);
    void resetTime();
    void nextCycle();
    int maxTime();
    int getTime();
    bool isQubitFree(int i, int j);
    bool isAllQubitFree();
    bool isSimpleGridDevice();
    bool isSupportSwapGate();

Detailed Documentation

Construction

ExGridDevice(int m, int n, std::vector<std::pair<int, int>>& qpairs)

constructor constructor

whose elements are like <q1, q2>

Parameters:

m	the grid side length
n	the grid side length
qpairs	set of adjacent qubit pairs

class QPanda::Exp

enum QPanda::Exp::ContentType

#include <QASMToQProg.h>

enum ContentType
{
    VAR_NAME  = 0,
    OP_EXPR,
    CONST_VAL,
};

struct QPanda::Exp::Content

#include <QASMToQProg.h>

struct Content
{
    // fields

    std::string var_name;
    std::string op_specifier;
    double const_value;
};

Overview

Saves the expression containing the variable. More…

#include <QASMToQProg.h>

class Exp
{
public:
    // enums

    enum ContentType;

    // structs

    struct Content;

    // construction

    Exp(std::string name);

    Exp(
        std::shared_ptr<Exp> left_exp_ptr,
        std::shared_ptr<Exp> right_exp_ptr,
        std::string op
        );

    Exp(double val);

    // methods

    std::shared_ptr<Exp> clone();
    void set_formal_actual_var_map(std::map<std::string, double> name_val_map);
    double eval();
};

Detailed Documentation

Saves the expression containing the variable.

Methods

std::shared_ptr<Exp> clone()

clone Exp class

Returns:

std::shared_ptr<Exp> Exp class shared ptr

double eval()

evaluation

Returns:

double operation rusult

class QPanda::FillQProg

Overview

Fill quantum program by I quantum gate. More…

#include <FillQProg.h>

class FillQProg
{
public:
    // construction

    FillQProg(QProg& input_prog);

    // methods

    void fill_by_I();
    QProg& get_output_prog();

    QVec get_unused_qubits_in_layer(
        QVec& all_qubits,
        QVec& inuse_qubits
        );
};

Detailed Documentation

Fill quantum program by I quantum gate.

Methods

void fill_by_I()

Fill the input QProg by I gate.

class QPanda::GetAllNodeType

Overview

get all the node type of the target QProg More…

#include <QCircuitInfo.h>

class GetAllNodeType: public QPanda::TraverseByNodeIter
{
public:
    // methods

    std::string printNodesType();

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);

Detailed Documentation

get all the node type of the target QProg

Methods

std::string printNodesType()

output the node type string

Returns:

std::string node type string

class QPanda::GetAllUsedQubitAndCBit

get all used qubit and cbit

#include <GetAllUsedQubitAndCBit.h>

class GetAllUsedQubitAndCBit: public QPanda::TraverseByNodeIter
{
public:
    // methods

    template <typename _Ty>
    void traversal(_Ty& node);

    QVec get_used_qubits();
    std::vector<int> get_used_cbits();
    std::vector<std::pair<uint32_t, uint32_t>> get_measure_info();
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);

class QPanda::GraphDijkstra

Overview

Solutions for Dijkstra algorithm. More…

#include <GraphDijkstra.h>

class GraphDijkstra
{
public:
    // construction

    GraphDijkstra();
    GraphDijkstra(const std::vector<std::vector<int>>& matrix);

    // methods

    int getShortestPath(int begin, int end, std::vector<int>& path_vec);
    bool is_connective();
};

Detailed Documentation

Solutions for Dijkstra algorithm.

Methods

int getShortestPath(int begin, int end, std::vector<int>& path_vec)

Get the shortest path of the graph between begin with end.

Parameters:

int	Begin: starting point
int	End: end point
std::vector<int>&	path_vec: The points at which the shortes path passes

Returns:

int The length of the shortes path

bool is_connective()

Determine if the graph is connected.

Returns:

bool Result of the judgement

See also:

class QPanda::JsonConfigParam

Overview

json configuration parameter More…

#include <JsonConfigParam.h>

class JsonConfigParam
{
public:
    // methods

    bool load_config(const std::string config_data = CONFIG_PATH);
    rapidjson::Document& get_root_element();

    bool getMetadataConfig(
        int& qubit_num,
        std::vector<std::vector<double>>& qubit_matrix
        );

    bool getClassNameConfig(std::map<std::string, std::string>& class_names);
    bool getQuantumCloudConfig(std::map<std::string, std::string>& cloud_config);

    bool getQGateConfig(
        std::vector<std::string>& single_gates,
        std::vector<std::string>& double_gates
        );

    bool getQGateTimeConfig(std::map<GateType, size_t>& gate_time);
    bool getInstructionConfig(std::map<std::string, std::map<std::string, uint32_t>>&);

    static bool readAdjacentMatrix(
        const rapidjson::Value& AdjacentMatrixElement,
        int& qubit_num,
        std::vector<std::vector<double>>& qubit_matrix
        );

    static bool loadQuantumTopoStructure(
        const std::string& xmlStr,
        const std::string& dataElementStr,
        int& qubitsCnt,
        std::vector<std::vector<double>>& vec,
        const std::string configFile = ""
        );
};

Detailed Documentation

json configuration parameter

Methods

bool load_config(const std::string config_data = CONFIG_PATH)

Load config data.

Parameters:

const

std::string It can be configuration file or configuration data, which can be distinguished by file suffix, so the configuration file must be end with “.json”, default is CONFIG_PATH

Returns:

Return false if any error occurs, otherwise return true

static bool readAdjacentMatrix(
    const rapidjson::Value& AdjacentMatrixElement,
    int& qubit_num,
    std::vector<std::vector<double>>& qubit_matrix
    )

read topological structure from json config file

Parameters:

const	rapidjson::Value& json value
int&	qubit number
std::vector<std::vector<int>>	qubit matrix

Returns:

bool

static bool loadQuantumTopoStructure(
    const std::string& xmlStr,
    const std::string& dataElementStr,
    int& qubitsCnt,
    std::vector<std::vector<double>>& vec,
    const std::string configFile = ""
    )

load quantum circuit topological structure

class QPanda::KAK

Overview

KAK decomposition via Magic Bell basis transformation. More…

#include <KAK.h>

class KAK
{
public:
    // methods

    KakDescription decompose(const Eigen::Matrix4cd& in_matrix);
};

Detailed Documentation

KAK decomposition via Magic Bell basis transformation.

Reference: https://arxiv.org/pdf/quant-ph/0211002.pdf

class QPanda::MergeSingleGate

Overview

Merge single gate in qprog. More…

#include <TransformDecomposition.h>

class MergeSingleGate: public QPanda::TraversalInterface
{
public:
    // methods

    void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node);
    void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node);
    void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Merge single gate in qprog.

Methods

void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class QPanda::MetadataValidity

Metadata Validity.

#include <MetadataValidity.h>

class MetadataValidity
{
public:
    // methods

    void push_back(MetadataValidity_cb func);
    MetadataValidity_cb operator [] (int i);
    size_t size();
};

class QPanda::NodeInfo

Overview

Detailed information of a QProg node. More…

#include <QCircuitInfo.h>

class NodeInfo
{
public:
    // fields

    NodeIter m_iter;
    NodeType m_node_type;
    GateType m_gate_type;
    bool m_is_dagger;
    QVec m_target_qubits;
    QVec m_control_qubits;
    std::vector<int> m_cbits;
    std::vector<double> m_params;
    std::string m_name;

    // construction

    NodeInfo();

    NodeInfo(
        const NodeIter iter,
        QVec target_qubits,
        QVec control_qubits,
        int type,
        const bool dagger
        );

    // methods

    virtual void reset();
};

// direct descendants

struct OptimizerNodeInfo;

Detailed Documentation

Detailed information of a QProg node.

Fields

NodeIter m_iter

the NodeIter of the node

NodeType m_node_type

the node type

GateType m_gate_type

the gate type (if the node type is gate_node)

bool m_is_dagger

dagger information

QVec m_target_qubits

Quantum bits of current node.

QVec m_control_qubits

control Quantum bits.

Construction

NodeInfo()

Constructor of NodeInfo.

Methods

virtual void reset()

reset the node information

class QPanda::OriginIRVisitor

enum QPanda::OriginIRVisitor::OpType

#include <OriginIRToQProg.h>

enum OpType
{
    UnaryPlus,
    UnaryMinus,
    UnaryNot,
    Plus,
    Minus,
    Mul,
    Div,
    LT,
    GT,
    LEQ,
    GEQ,
    EQ,
    NE,
    AND,
    OR,
    ASSIGN,
};

struct QPanda::OriginIRVisitor::ExprContext

struct ExprContext
{
    // fields

    bool isConstant;
    double value;
    size_t ccid;
};

struct QPanda::OriginIRVisitor::GateContext

struct GateContext
{
    // fields

    QProgBuilder::GateType gatetype;
};

Overview

OriginIR Visitor. More…

#include <OriginIRToQProg.h>

class OriginIRVisitor: public originirBaseVisitor
{
public:
    // enums

    enum OpType;

    // structs

    struct ExprContext;
    struct GateContext;

    // construction

    OriginIRVisitor(
        QuantumMachine* qm,
        QVec& qv,
        std::vector<ClassicalCondition>& cv
        );

    // methods

    QProg get_qprog(size_t progid);
    virtual antlrcpp::Any visitTranslationunit(originirParser::TranslationunitContext* context);
    virtual antlrcpp::Any visitQinit_declaration(originirParser::Qinit_declarationContext* ctx);
    virtual antlrcpp::Any visitCinit_declaration(originirParser::Cinit_declarationContext* ctx);
    virtual antlrcpp::Any visitIndex(originirParser::IndexContext* ctx);
    virtual antlrcpp::Any visitC_KEY_declaration(originirParser::C_KEY_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_without_parameter_declaration(originirParser::Single_gate_without_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_one_parameter_declaration(originirParser::Single_gate_with_one_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_two_parameter_declaration(originirParser::Single_gate_with_two_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_three_parameter_declaration(originirParser::Single_gate_with_three_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_four_parameter_declaration(originirParser::Single_gate_with_four_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_without_parameter_declaration(originirParser::Double_gate_without_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_with_one_parameter_declaration(originirParser::Double_gate_with_one_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_with_four_parameter_declaration(originirParser::Double_gate_with_four_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitTriple_gate_without_parameter_declaration(originirParser::Triple_gate_without_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_without_parameter_type(originirParser::Single_gate_without_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_one_parameter_type(originirParser::Single_gate_with_one_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_two_parameter_type(originirParser::Single_gate_with_two_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_three_parameter_type(originirParser::Single_gate_with_three_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_four_parameter_type(originirParser::Single_gate_with_four_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_without_parameter_type(originirParser::Double_gate_without_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_with_one_parameter_type(originirParser::Double_gate_with_one_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_with_four_parameter_type(originirParser::Double_gate_with_four_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitTriple_gate_without_parameter_type(originirParser::Triple_gate_without_parameter_typeContext* ctx);

    void call_define_gatefunc(
        size_t prog_id,
        const std::string& func_name,
        const std::vector<ExprContext>& actual_qubits,
        const std::vector<double>& actual_angles
        );

    virtual antlrcpp::Any visitDefine_gate_declaration(originirParser::Define_gate_declarationContext* ctx);
    virtual antlrcpp::Any visitPri_ckey(originirParser::Pri_ckeyContext* ctx);
    virtual antlrcpp::Any visitPri_cst(originirParser::Pri_cstContext* ctx);
    virtual antlrcpp::Any visitPri_expr(originirParser::Pri_exprContext* ctx);
    virtual antlrcpp::Any visitUnary_expression(originirParser::Unary_expressionContext* ctx);
    virtual antlrcpp::Any visitMultiplicative_expression(originirParser::Multiplicative_expressionContext* ctx);
    virtual antlrcpp::Any visitAddtive_expression(originirParser::Addtive_expressionContext* ctx);
    virtual antlrcpp::Any visitRelational_expression(originirParser::Relational_expressionContext* ctx);
    virtual antlrcpp::Any visitEquality_expression(originirParser::Equality_expressionContext* ctx);
    virtual antlrcpp::Any visitLogical_and_expression(originirParser::Logical_and_expressionContext* ctx);
    virtual antlrcpp::Any visitLogical_or_expression(originirParser::Logical_or_expressionContext* ctx);
    virtual antlrcpp::Any visitAssignment_expression(originirParser::Assignment_expressionContext* ctx);
    virtual antlrcpp::Any visitControlbit_list(originirParser::Controlbit_listContext* ctx);
    virtual antlrcpp::Any visitStatement(originirParser::StatementContext* ctx);
    virtual antlrcpp::Any visitDagger_statement(originirParser::Dagger_statementContext* ctx);
    virtual antlrcpp::Any visitControl_statement(originirParser::Control_statementContext* ctx);
    virtual antlrcpp::Any visitQelse_statement_fragment(originirParser::Qelse_statement_fragmentContext* ctx);
    virtual antlrcpp::Any visitQif_if(originirParser::Qif_ifContext* ctx);
    virtual antlrcpp::Any visitQif_ifelse(originirParser::Qif_ifelseContext* ctx);
    virtual antlrcpp::Any visitQwhile_statement(originirParser::Qwhile_statementContext* ctx);
    virtual antlrcpp::Any visitMeasure_statement(originirParser::Measure_statementContext* ctx);
    virtual antlrcpp::Any visitReset_statement(originirParser::Reset_statementContext* ctx);
    virtual antlrcpp::Any visitBarrier_statement(originirParser::Barrier_statementContext* ctx);
    virtual antlrcpp::Any visitExpression_statement(originirParser::Expression_statementContext* ctx);
    virtual antlrcpp::Any visitDefine_gate_statement(originirParser::Define_gate_statementContext* ctx);
    virtual antlrcpp::Any visitExplist(originirParser::ExplistContext* ctx);
    virtual antlrcpp::Any visitExp(originirParser::ExpContext* ctx);
    virtual antlrcpp::Any visitGate_func_statement(originirParser::Gate_func_statementContext* ctx);
    virtual antlrcpp::Any visitId_list(originirParser::Id_listContext* ctx);
};

Inherited Members

public:
    // methods

    virtual antlrcpp::Any visitTranslationunit(originirParser::TranslationunitContext* context) = 0;
    virtual antlrcpp::Any visitDeclaration(originirParser::DeclarationContext* context) = 0;
    virtual antlrcpp::Any visitQinit_declaration(originirParser::Qinit_declarationContext* context) = 0;
    virtual antlrcpp::Any visitCinit_declaration(originirParser::Cinit_declarationContext* context) = 0;
    virtual antlrcpp::Any visitQuantum_gate_declaration(originirParser::Quantum_gate_declarationContext* context) = 0;
    virtual antlrcpp::Any visitIndex(originirParser::IndexContext* context) = 0;
    virtual antlrcpp::Any visitC_KEY_declaration(originirParser::C_KEY_declarationContext* context) = 0;
    virtual antlrcpp::Any visitQ_KEY_declaration(originirParser::Q_KEY_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_without_parameter_declaration(originirParser::Single_gate_without_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_one_parameter_declaration(originirParser::Single_gate_with_one_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_two_parameter_declaration(originirParser::Single_gate_with_two_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_three_parameter_declaration(originirParser::Single_gate_with_three_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_four_parameter_declaration(originirParser::Single_gate_with_four_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_without_parameter_declaration(originirParser::Double_gate_without_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_with_one_parameter_declaration(originirParser::Double_gate_with_one_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_with_four_parameter_declaration(originirParser::Double_gate_with_four_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitTriple_gate_without_parameter_declaration(originirParser::Triple_gate_without_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitDefine_gate_declaration(originirParser::Define_gate_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_without_parameter_type(originirParser::Single_gate_without_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_one_parameter_type(originirParser::Single_gate_with_one_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_two_parameter_type(originirParser::Single_gate_with_two_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_three_parameter_type(originirParser::Single_gate_with_three_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_four_parameter_type(originirParser::Single_gate_with_four_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_without_parameter_type(originirParser::Double_gate_without_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_with_one_parameter_type(originirParser::Double_gate_with_one_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_with_four_parameter_type(originirParser::Double_gate_with_four_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitTriple_gate_without_parameter_type(originirParser::Triple_gate_without_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitPri_ckey(originirParser::Pri_ckeyContext* context) = 0;
    virtual antlrcpp::Any visitPri_cst(originirParser::Pri_cstContext* context) = 0;
    virtual antlrcpp::Any visitPri_expr(originirParser::Pri_exprContext* context) = 0;
    virtual antlrcpp::Any visitUnary_expression(originirParser::Unary_expressionContext* context) = 0;
    virtual antlrcpp::Any visitMultiplicative_expression(originirParser::Multiplicative_expressionContext* context) = 0;
    virtual antlrcpp::Any visitAddtive_expression(originirParser::Addtive_expressionContext* context) = 0;
    virtual antlrcpp::Any visitRelational_expression(originirParser::Relational_expressionContext* context) = 0;
    virtual antlrcpp::Any visitEquality_expression(originirParser::Equality_expressionContext* context) = 0;
    virtual antlrcpp::Any visitLogical_and_expression(originirParser::Logical_and_expressionContext* context) = 0;
    virtual antlrcpp::Any visitLogical_or_expression(originirParser::Logical_or_expressionContext* context) = 0;
    virtual antlrcpp::Any visitAssignment_expression(originirParser::Assignment_expressionContext* context) = 0;
    virtual antlrcpp::Any visitExpression(originirParser::ExpressionContext* context) = 0;
    virtual antlrcpp::Any visitControlbit_list(originirParser::Controlbit_listContext* context) = 0;
    virtual antlrcpp::Any visitStatement(originirParser::StatementContext* context) = 0;
    virtual antlrcpp::Any visitDagger_statement(originirParser::Dagger_statementContext* context) = 0;
    virtual antlrcpp::Any visitControl_statement(originirParser::Control_statementContext* context) = 0;
    virtual antlrcpp::Any visitQelse_statement_fragment(originirParser::Qelse_statement_fragmentContext* context) = 0;
    virtual antlrcpp::Any visitQif_if(originirParser::Qif_ifContext* context) = 0;
    virtual antlrcpp::Any visitQif_ifelse(originirParser::Qif_ifelseContext* context) = 0;
    virtual antlrcpp::Any visitQwhile_statement(originirParser::Qwhile_statementContext* context) = 0;
    virtual antlrcpp::Any visitMeasure_statement(originirParser::Measure_statementContext* context) = 0;
    virtual antlrcpp::Any visitReset_statement(originirParser::Reset_statementContext* context) = 0;
    virtual antlrcpp::Any visitBarrier_statement(originirParser::Barrier_statementContext* context) = 0;
    virtual antlrcpp::Any visitExpression_statement(originirParser::Expression_statementContext* context) = 0;
    virtual antlrcpp::Any visitDefine_gate_statement(originirParser::Define_gate_statementContext* context) = 0;
    virtual antlrcpp::Any visitExplist(originirParser::ExplistContext* context) = 0;
    virtual antlrcpp::Any visitExp(originirParser::ExpContext* context) = 0;
    virtual antlrcpp::Any visitGate_func_statement(originirParser::Gate_func_statementContext* context) = 0;
    virtual antlrcpp::Any visitId(originirParser::IdContext* context) = 0;
    virtual antlrcpp::Any visitId_list(originirParser::Id_listContext* context) = 0;
    virtual antlrcpp::Any visitGate_name(originirParser::Gate_nameContext* context) = 0;
    virtual antlrcpp::Any visitConstant(originirParser::ConstantContext* context) = 0;
    virtual antlrcpp::Any visitTranslationunit(originirParser::TranslationunitContext* context);
    virtual antlrcpp::Any visitDeclaration(originirParser::DeclarationContext* ctx);
    virtual antlrcpp::Any visitQinit_declaration(originirParser::Qinit_declarationContext* ctx);
    virtual antlrcpp::Any visitCinit_declaration(originirParser::Cinit_declarationContext* ctx);
    virtual antlrcpp::Any visitQuantum_gate_declaration(originirParser::Quantum_gate_declarationContext* ctx);
    virtual antlrcpp::Any visitIndex(originirParser::IndexContext* ctx);
    virtual antlrcpp::Any visitC_KEY_declaration(originirParser::C_KEY_declarationContext* ctx);
    virtual antlrcpp::Any visitQ_KEY_declaration(originirParser::Q_KEY_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_without_parameter_declaration(originirParser::Single_gate_without_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_one_parameter_declaration(originirParser::Single_gate_with_one_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_two_parameter_declaration(originirParser::Single_gate_with_two_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_three_parameter_declaration(originirParser::Single_gate_with_three_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_four_parameter_declaration(originirParser::Single_gate_with_four_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_without_parameter_declaration(originirParser::Double_gate_without_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_with_one_parameter_declaration(originirParser::Double_gate_with_one_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_with_four_parameter_declaration(originirParser::Double_gate_with_four_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitTriple_gate_without_parameter_declaration(originirParser::Triple_gate_without_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitDefine_gate_declaration(originirParser::Define_gate_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_without_parameter_type(originirParser::Single_gate_without_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_one_parameter_type(originirParser::Single_gate_with_one_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_two_parameter_type(originirParser::Single_gate_with_two_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_three_parameter_type(originirParser::Single_gate_with_three_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_four_parameter_type(originirParser::Single_gate_with_four_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_without_parameter_type(originirParser::Double_gate_without_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_with_one_parameter_type(originirParser::Double_gate_with_one_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_with_four_parameter_type(originirParser::Double_gate_with_four_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitTriple_gate_without_parameter_type(originirParser::Triple_gate_without_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitPri_ckey(originirParser::Pri_ckeyContext* ctx);
    virtual antlrcpp::Any visitPri_cst(originirParser::Pri_cstContext* ctx);
    virtual antlrcpp::Any visitPri_expr(originirParser::Pri_exprContext* ctx);
    virtual antlrcpp::Any visitUnary_expression(originirParser::Unary_expressionContext* ctx);
    virtual antlrcpp::Any visitMultiplicative_expression(originirParser::Multiplicative_expressionContext* ctx);
    virtual antlrcpp::Any visitAddtive_expression(originirParser::Addtive_expressionContext* ctx);
    virtual antlrcpp::Any visitRelational_expression(originirParser::Relational_expressionContext* ctx);
    virtual antlrcpp::Any visitEquality_expression(originirParser::Equality_expressionContext* ctx);
    virtual antlrcpp::Any visitLogical_and_expression(originirParser::Logical_and_expressionContext* ctx);
    virtual antlrcpp::Any visitLogical_or_expression(originirParser::Logical_or_expressionContext* ctx);
    virtual antlrcpp::Any visitAssignment_expression(originirParser::Assignment_expressionContext* ctx);
    virtual antlrcpp::Any visitExpression(originirParser::ExpressionContext* ctx);
    virtual antlrcpp::Any visitControlbit_list(originirParser::Controlbit_listContext* ctx);
    virtual antlrcpp::Any visitStatement(originirParser::StatementContext* ctx);
    virtual antlrcpp::Any visitDagger_statement(originirParser::Dagger_statementContext* ctx);
    virtual antlrcpp::Any visitControl_statement(originirParser::Control_statementContext* ctx);
    virtual antlrcpp::Any visitQelse_statement_fragment(originirParser::Qelse_statement_fragmentContext* ctx);
    virtual antlrcpp::Any visitQif_if(originirParser::Qif_ifContext* ctx);
    virtual antlrcpp::Any visitQif_ifelse(originirParser::Qif_ifelseContext* ctx);
    virtual antlrcpp::Any visitQwhile_statement(originirParser::Qwhile_statementContext* ctx);
    virtual antlrcpp::Any visitMeasure_statement(originirParser::Measure_statementContext* ctx);
    virtual antlrcpp::Any visitReset_statement(originirParser::Reset_statementContext* ctx);
    virtual antlrcpp::Any visitBarrier_statement(originirParser::Barrier_statementContext* ctx);
    virtual antlrcpp::Any visitExpression_statement(originirParser::Expression_statementContext* ctx);
    virtual antlrcpp::Any visitDefine_gate_statement(originirParser::Define_gate_statementContext* ctx);
    virtual antlrcpp::Any visitExplist(originirParser::ExplistContext* ctx);
    virtual antlrcpp::Any visitExp(originirParser::ExpContext* ctx);
    virtual antlrcpp::Any visitGate_func_statement(originirParser::Gate_func_statementContext* ctx);
    virtual antlrcpp::Any visitId(originirParser::IdContext* ctx);
    virtual antlrcpp::Any visitId_list(originirParser::Id_listContext* ctx);
    virtual antlrcpp::Any visitGate_name(originirParser::Gate_nameContext* ctx);
    virtual antlrcpp::Any visitConstant(originirParser::ConstantContext* ctx);

Detailed Documentation

OriginIR Visitor.

Methods

virtual antlrcpp::Any visitTranslationunit(originirParser::TranslationunitContext* context)

Visit parse trees produced by originirParser.

class QPanda::QASMToQProg

Overview

QASM instruction sets convert to quantum program. More…

#include <QASMToQProg.h>

class QASMToQProg: public qasmBaseVisitor
{
public:
    // construction

    QASMToQProg(
        QuantumMachine* qvm,
        QVec& qv,
        std::vector<ClassicalCondition>& cv
        );

    // methods

    virtual antlrcpp::Any visitMainprogram(qasmParser::MainprogramContext* ctx);
    virtual antlrcpp::Any visitHead_decl(qasmParser::Head_declContext* ctx);
    virtual antlrcpp::Any visitVersion_decl(qasmParser::Version_declContext* ctx);
    virtual antlrcpp::Any visitInclude_decl(qasmParser::Include_declContext* ctx);
    virtual antlrcpp::Any visitStatement(qasmParser::StatementContext* ctx);
    virtual antlrcpp::Any visitReg_decl(qasmParser::Reg_declContext* ctx);
    virtual antlrcpp::Any visitOpaque_decl(qasmParser::Opaque_declContext* ctx);
    virtual antlrcpp::Any visitIf_decl(qasmParser::If_declContext* ctx);
    virtual antlrcpp::Any visitBarrier_decl(qasmParser::Barrier_declContext* ctx);
    virtual antlrcpp::Any visitGate_decl(qasmParser::Gate_declContext* ctx);
    virtual antlrcpp::Any visitGoplist(qasmParser::GoplistContext* ctx);
    virtual antlrcpp::Any visitBop(qasmParser::BopContext* ctx);
    virtual antlrcpp::Any visitQop(qasmParser::QopContext* ctx);
    virtual antlrcpp::Any visitUop(qasmParser::UopContext* ctx);
    virtual antlrcpp::Any visitAnylist(qasmParser::AnylistContext* ctx);
    virtual antlrcpp::Any visitIdlist(qasmParser::IdlistContext* ctx);
    virtual antlrcpp::Any visitArgument(qasmParser::ArgumentContext* ctx);
    virtual antlrcpp::Any visitId_index(qasmParser::Id_indexContext* ctx);
    virtual antlrcpp::Any visitExplist(qasmParser::ExplistContext* ctx);
    virtual antlrcpp::Any visitExp(qasmParser::ExpContext* ctx);
    virtual antlrcpp::Any visitId(qasmParser::IdContext* ctx);
    virtual antlrcpp::Any visitInteger(qasmParser::IntegerContext* ctx);
    virtual antlrcpp::Any visitReal(qasmParser::RealContext* ctx);
    virtual antlrcpp::Any visitDecimal(qasmParser::DecimalContext* ctx);
    virtual antlrcpp::Any visitFilename(qasmParser::FilenameContext* ctx);
    QVec find_qvec_map_value(std::string str_key);
    std::vector<ClassicalCondition> find_cvec_map_value(std::string str_key);

    void execute_gate_function(
        GateOperationInfo op_info,
        QProg& prog
        );

    void build_zero_param_single_gate(
        QASMGateType type,
        bool is_dagger,
        GateOperationInfo op_info,
        QProg& prog
        );

    void build_one_param_single_gate(
        QASMGateType type,
        GateOperationInfo op_info,
        QProg& prog
        );

    void build_two_param_single_gate_func(
        QASMGateType type,
        GateOperationInfo op_info,
        QProg& prog
        );

    void build_three_param_single_gate(
        QASMGateType type,
        GateOperationInfo op_info,
        QProg& prog
        );

    void build_zero_param_double_gate(
        QASMGateType type,
        GateOperationInfo op_info,
        QProg& prog
        );

    void build_zero_param_triple_gate(
        QASMGateType type,
        GateOperationInfo op_info,
        QProg& prog
        );

    void build_zero_param_double_circuit(
        QASMGateType type,
        GateOperationInfo op_info,
        QProg& prog
        );

    void build_one_param_double_circuit(
        QASMGateType type,
        GateOperationInfo op_info,
        QProg& prog
        );

    void build_three_param_double_circuit(
        QASMGateType type,
        GateOperationInfo op_info,
        QProg& prog
        );

    void build_qprog(
        GateOperationInfo op_info,
        QProg& prog
        );

    QProg get_qprog();
};

Inherited Members

public:
    // methods

    virtual antlrcpp::Any visitMainprogram(qasmParser::MainprogramContext* context) = 0;
    virtual antlrcpp::Any visitHead_decl(qasmParser::Head_declContext* context) = 0;
    virtual antlrcpp::Any visitVersion_decl(qasmParser::Version_declContext* context) = 0;
    virtual antlrcpp::Any visitInclude_decl(qasmParser::Include_declContext* context) = 0;
    virtual antlrcpp::Any visitStatement(qasmParser::StatementContext* context) = 0;
    virtual antlrcpp::Any visitReg_decl(qasmParser::Reg_declContext* context) = 0;
    virtual antlrcpp::Any visitOpaque_decl(qasmParser::Opaque_declContext* context) = 0;
    virtual antlrcpp::Any visitIf_decl(qasmParser::If_declContext* context) = 0;
    virtual antlrcpp::Any visitBarrier_decl(qasmParser::Barrier_declContext* context) = 0;
    virtual antlrcpp::Any visitGate_decl(qasmParser::Gate_declContext* context) = 0;
    virtual antlrcpp::Any visitGoplist(qasmParser::GoplistContext* context) = 0;
    virtual antlrcpp::Any visitBop(qasmParser::BopContext* context) = 0;
    virtual antlrcpp::Any visitQop(qasmParser::QopContext* context) = 0;
    virtual antlrcpp::Any visitUop(qasmParser::UopContext* context) = 0;
    virtual antlrcpp::Any visitAnylist(qasmParser::AnylistContext* context) = 0;
    virtual antlrcpp::Any visitIdlist(qasmParser::IdlistContext* context) = 0;
    virtual antlrcpp::Any visitId_index(qasmParser::Id_indexContext* context) = 0;
    virtual antlrcpp::Any visitArgument(qasmParser::ArgumentContext* context) = 0;
    virtual antlrcpp::Any visitExplist(qasmParser::ExplistContext* context) = 0;
    virtual antlrcpp::Any visitExp(qasmParser::ExpContext* context) = 0;
    virtual antlrcpp::Any visitId(qasmParser::IdContext* context) = 0;
    virtual antlrcpp::Any visitReal(qasmParser::RealContext* context) = 0;
    virtual antlrcpp::Any visitInteger(qasmParser::IntegerContext* context) = 0;
    virtual antlrcpp::Any visitDecimal(qasmParser::DecimalContext* context) = 0;
    virtual antlrcpp::Any visitFilename(qasmParser::FilenameContext* context) = 0;
    virtual antlrcpp::Any visitMainprogram(qasmParser::MainprogramContext* context);
    virtual antlrcpp::Any visitHead_decl(qasmParser::Head_declContext* ctx);
    virtual antlrcpp::Any visitVersion_decl(qasmParser::Version_declContext* ctx);
    virtual antlrcpp::Any visitInclude_decl(qasmParser::Include_declContext* ctx);
    virtual antlrcpp::Any visitStatement(qasmParser::StatementContext* ctx);
    virtual antlrcpp::Any visitReg_decl(qasmParser::Reg_declContext* ctx);
    virtual antlrcpp::Any visitOpaque_decl(qasmParser::Opaque_declContext* ctx);
    virtual antlrcpp::Any visitIf_decl(qasmParser::If_declContext* ctx);
    virtual antlrcpp::Any visitBarrier_decl(qasmParser::Barrier_declContext* ctx);
    virtual antlrcpp::Any visitGate_decl(qasmParser::Gate_declContext* ctx);
    virtual antlrcpp::Any visitGoplist(qasmParser::GoplistContext* ctx);
    virtual antlrcpp::Any visitBop(qasmParser::BopContext* ctx);
    virtual antlrcpp::Any visitQop(qasmParser::QopContext* ctx);
    virtual antlrcpp::Any visitUop(qasmParser::UopContext* ctx);
    virtual antlrcpp::Any visitAnylist(qasmParser::AnylistContext* ctx);
    virtual antlrcpp::Any visitIdlist(qasmParser::IdlistContext* ctx);
    virtual antlrcpp::Any visitId_index(qasmParser::Id_indexContext* ctx);
    virtual antlrcpp::Any visitArgument(qasmParser::ArgumentContext* ctx);
    virtual antlrcpp::Any visitExplist(qasmParser::ExplistContext* ctx);
    virtual antlrcpp::Any visitExp(qasmParser::ExpContext* ctx);
    virtual antlrcpp::Any visitId(qasmParser::IdContext* ctx);
    virtual antlrcpp::Any visitReal(qasmParser::RealContext* ctx);
    virtual antlrcpp::Any visitInteger(qasmParser::IntegerContext* ctx);
    virtual antlrcpp::Any visitDecimal(qasmParser::DecimalContext* ctx);
    virtual antlrcpp::Any visitFilename(qasmParser::FilenameContext* ctx);

Detailed Documentation

QASM instruction sets convert to quantum program.

Methods

virtual antlrcpp::Any visitMainprogram(qasmParser::MainprogramContext* ctx)

They are abstract visitors for a parse tree produced by qasmParser.

QProg get_qprog()

get converted quantum programs

Returns:

QProg

class QPanda::QCircuitParam

Overview

Circuit Parameter information. More…

#include <QCircuitInfo.h>

class QCircuitParam
{
public:
    // fields

    bool m_is_dagger;
    QVec m_control_qubits;

    // construction

    QCircuitParam();
    QCircuitParam(const QCircuitParam& rhs);

    // methods

    virtual std::shared_ptr<QCircuitParam> clone();
    void append_control_qubits(const QVec& ctrl_qubits);
    static QVec get_real_append_qubits(QVec append_qubits, QVec target_qubits);
};

// direct descendants

class QCirParamForDAG;

Detailed Documentation

Circuit Parameter information.

Fields

bool m_is_dagger

dagger information

QVec m_control_qubits

control Quantum bits

Construction

QCircuitParam()

Constructor of QCircuitParam.

QCircuitParam(const QCircuitParam& rhs)

copy constructor

Methods

virtual std::shared_ptr<QCircuitParam> clone()

clone

void append_control_qubits(const QVec& ctrl_qubits)

append control qubits

Parameters:

QVec&

control qubits

static QVec get_real_append_qubits(QVec append_qubits, QVec target_qubits)

get the real increased control qubits

Parameters:

QVec	increased control qubits, maybe some repeat exist
QVec	already controled qubits

Returns:

QVec the real increased control qubits

class QPanda::QCodarMatch

Overview

A Contextual Duration-Aware Qubit Mapping (CODAR) More…

#include <QCodarMatch.h>

class QCodarMatch: public QPanda::TraversalInterface
{
public:
    // construction

    QCodarMatch(
        QuantumMachine* machine,
        QProg prog,
        QCodarGridDevice arch_type,
        int m,
        int n,
        const std::string config_data = CONFIG_PATH
        );

    // methods

    void initScheduler(
        QCodarGridDevice arch_type,
        size_t qubits
        );

    void initGridDevice(
        QCodarGridDevice arch_type,
        int& m,
        int& n
        );

    void mappingQProg(size_t run_times, QVec& qv, QProg& mapped_prog);

    void buildResultingQProg(
        const std::vector<GateInfo> resulting_gates,
        const std::vector<int> map_vec,
        QVec& q,
        QProg& prog
        );

    void traversalQProgParsingInfo(QProg* prog);

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

A Contextual Duration-Aware Qubit Mapping (CODAR)

Methods

void mappingQProg(size_t run_times, QVec& qv, QProg& mapped_prog)

Mapping qubits in a quantum program.

Parameters:

size_t	run_times : the number of times run the remapping
QVec	qubits vector
Qprog&	the mapped quantum program

Returns:

void

void buildResultingQProg(
    const std::vector<GateInfo> resulting_gates,
    const std::vector<int> map_vec,
    QVec& q,
    QProg& prog
    )

build QProg by the mapping results

Parameters:

std::vector<GateInfo>	gates info vector
std::vector<int>	map vector
Qprog&	the mapped quantum program

Returns:

void

void traversalQProgParsingInfo(QProg* prog)

traversal quantum program and Parsing quantum program information

Parameters:

QProg*

quantum program pointer

Returns:

void

class QPanda::QGateCompare

Overview

Qunatum Gate Compare. More…

#include <QGateCompare.h>

class QGateCompare: public QPanda::TraversalInterface
{
public:
    // construction

    QGateCompare(const std::vector<std::vector<std::string>>&);

    // methods

    template <typename _Ty>
    void traversal(_Ty node);

    template <typename _Ty>
    void traversal(std::shared_ptr<_Ty> node);

    size_t count();
    virtual void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Qunatum Gate Compare.

Methods

template <typename _Ty>
void traversal(_Ty node)

traversal quantum program, quantum circuit, quantum while or quantum if

Parameters:

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

Returns:

void

size_t count()

get unsupported gate numner

Returns:

size_t Unsupported QGate number

virtual void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class QPanda::QGateCounter

Overview

Count quantum gate num in quantum program, quantum circuit, quantum while, quantum if. More…

#include <QGateCounter.h>

class QGateCounter: public QPanda::TraversalInterface
{
public:
    // methods

    template <typename _Ty>
    void traversal(_Ty& node);

    size_t count();
    virtual void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

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

Methods

virtual void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class QPanda::QPandaException

QPanda2 exception basic class.

#include <QPandaException.h>

class QPandaException: public runtime_error
{
public:
    // construction

    QPandaException();
    QPandaException(const char* str);
    QPandaException(std::string str);

    // methods

    virtual const char* what();
};

// direct descendants

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

class QPanda::QProgBuilder

enum QPanda::QProgBuilder::GateType

#include <OriginIRToQProg.h>

enum GateType
{
    H,
    T,
    S,
    X,
    Y,
    Z,
    X1,
    Y1,
    Z1,
    I,
    ECHO,
    RX,
    RY,
    RZ,
    U1,
    U2,
    RPhi,
    U3,
    U4,
    CNOT,
    CZ,
    ISWAP,
    SQISWAP,
    SWAP,
    ISWAPTHETA,
    CR,
    CU,
    TOFFOLI,
    DEFINE_QAGE,
};

Quantum Program Builder.

#include <OriginIRToQProg.h>

class QProgBuilder
{
public:
    // enums

    enum GateType;

    // construction

    QProgBuilder(
        QuantumMachine* qm,
        QVec& qv,
        std::vector<ClassicalCondition>& cv
        );

    // methods

    QProg get_qprog();
    size_t get_qubits_size();
    size_t get_cbits_size();
    void set_define_qgate_function(const DefineQGateContent& define_qgate);
    DefineQGateContent get_define_qgate_function(const std::string& gate_name);
    void alloc_qubit(int num);
    void alloc_cbit(int num);
    size_t add_prog();

    void insert_subprog(
        size_t progid_dst,
        size_t progid_src
        );

    size_t add_qgate(
        GateType type,
        std::vector<int> index,
        std::vector<double> parameters
        );

    size_t add_qgate_cc(
        GateType type,
        std::vector<size_t> exprid,
        std::vector<int> index,
        std::vector<double> parameters
        );

    size_t add_measure_literal(
        size_t qidx,
        size_t cidx
        );

    size_t add_measure_cc(
        size_t exprid,
        size_t cidx
        );

    size_t add_reset_literal(size_t qidx);
    size_t add_reset_cc(size_t exprid);

    size_t add_barrier_literal(
        size_t exprid,
        QVec qv
        );

    size_t add_barrier_cc(
        size_t exprid,
        QVec qv
        );

    size_t add_expr_stat(size_t exprid);

    size_t make_qif(
        size_t exprid,
        size_t progid
        );

    size_t make_qifelse(
        size_t exprid,
        size_t progid_true,
        size_t progid_false
        );

    size_t make_qwhile(
        size_t exprid,
        size_t progid
        );

    void delete_prog(size_t progid);
    size_t cc_init_id(size_t cidx);
    size_t cc_init_literal(double value);

    size_t cc_op_cc(
        size_t exprid1,
        size_t exprid2,
        int op_type
        );

    size_t cc_op_literal(
        size_t exprid1,
        double literal2,
        int op_type
        );

    size_t literal_op_cc(
        double literal1,
        size_t exprid2,
        int op_type
        );

    size_t op_cc(
        size_t exprid,
        int op_type
        );

    void make_dagger(size_t progid);
    size_t make_dagger_new(size_t progid);

    void make_control(
        size_t progid,
        std::vector<int> idx
        );

    size_t make_control_new(
        size_t progid,
        std::vector<int> idx
        );

    QVec make_qvec(
        std::vector<size_t> expridx,
        std::vector<int> idx
        );

    void make_control_cc(
        size_t progid,
        std::vector<size_t> expridx,
        std::vector<int> idx
        );

    size_t make_control_cc_new(
        size_t progid,
        std::vector<size_t> expridx,
        std::vector<int> idx
        );

    static GateType get_gatetype(std::string gatename);
};

class QPanda::QProgClockCycle

Count Quantum Program clock cycle.

#include <QProgClockCycle.h>

class QProgClockCycle
{
public:
    // construction

    QProgClockCycle(QuantumMachine* qm);

    // methods

    size_t count(
        QProg& prog,
        bool optimize = false
        );
};

class QPanda::QProgDAG

Overview

transform QProg to DAG(directed acyclic graph) More…

#include <QProgDAG.h>

class QProgDAG
{
public:
    // fields

    std::map<uint32_t, Qubit*> m_qubits;

    // methods

    void add_vertex(std::shared_ptr<QProgDAGNode> n, DAGNodeType type);
    void get_adjacency_matrix(AdjacencyMatrix& matrix);
    const QProgDAGVertex& get_vertex(const size_t vertice_num) const;
    bool is_connected_graph();
    TopologSequence<DAGSeqNode> build_topo_sequence();
    std::set<QProgDAGEdge> get_edges() const;
    void remove_edge(const QProgDAGEdge& e);
    const std::vector<QProgDAGVertex>& get_vertex_c() const;
    std::vector<QProgDAGVertex>& get_vertex();
    const auto& get_qubit_vertices_map() const;
    std::shared_ptr<QProg> dag_to_qprog();
};

Detailed Documentation

transform QProg to DAG(directed acyclic graph)

transform QProg to DAG

Methods

void add_vertex(std::shared_ptr<QProgDAGNode> n, DAGNodeType type)

add vertex

Parameters:

node_info

Returns:

size_t vertex num

void get_adjacency_matrix(AdjacencyMatrix& matrix)

get adjacency_matrix

Parameters:

vertices_map&
AdjacencyMatrix&

Returns:

void

const QProgDAGVertex& get_vertex(const size_t vertice_num) const

get vertex by vertex num

Parameters:

size_t

vertex num

Returns:

std::shared_ptr<QPanda::QNode> qnode

class QPanda::QProgDataParse

class QPanda::QProgDataParse::DataNode

Quantum program node data.

class DataNode
{
public:
    // fields

    uint32_t qubit_data;
    float angle_data;

    // construction

    DataNode();
    DataNode(uint32_t data);
    DataNode(float data);
};

Overview

parse binary file to quantum program More…

#include <QProgDataParse.h>

class QProgDataParse
{
public:
    // classes

    class DataNode;

    // construction

    QProgDataParse(QuantumMachine* qm);

    // methods

    bool load(const std::string& filename);
    bool load(const std::vector<uint8_t>& data);
    bool parse(QProg& prog);
    QVec getQubits();
    std::vector<ClassicalCondition> getCbits();
};

Detailed Documentation

parse binary file to quantum program

Methods

bool load(const std::string& filename)

Load qprog data from file.

Parameters:

std::string&

filename

Returns:

bool

bool load(const std::vector<uint8_t>& data)

Load qprog data from data vector.

Parameters:

std::vector<uint8_t>&

data

Returns:

bool

bool parse(QProg& prog)

Parse binary file to QProg.

Parameters:

QProg&

prog

Returns:

bool

class QPanda::QProgFlattening

Overview

flatten quantum program and quantum circuit More…

#include <QProgFlattening.h>

class QProgFlattening: public QPanda::TraversalInterface
{
public:
    // construction

    QProgFlattening(bool is_full_faltten = true);

    // methods

    void flatten_circuit(QCircuit& src_cir);
    void flatten_prog(QProg& src_prog);

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QProg& prog
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QProg& prog
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QProg& prog
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QProg& prog
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QProg& prog
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QProg& prog
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QProg& prog
        );

    static QCircuit prog_flatten_to_cir(QProg& prog);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

flatten quantum program and quantum circuit

Methods

static QCircuit prog_flatten_to_cir(QProg& prog)

Flatten QProg to QCircuit.

Parameters:

QProg&

the target QProg

Returns:

Converted circuit @Note: The input QProg must be no-nesting, and only QGate type is supported.

class QPanda::QProgStored

union QPanda::QProgStored::DataNode

union DataNode
{
    // fields

    uint32_t qubit_data;
    float angle_data;

    // construction

    DataNode();
    DataNode(uint32_t uiData);
    DataNode(float fData);
};

Overview

Utilities class for quantum program stored to binary data. More…

#include <QProgStored.h>

class QProgStored: public QPanda::TraversalInterface
{
public:
    // unions

    union DataNode;

    // construction

    QProgStored(QuantumMachine* qm);

    // methods

    void transform(QProg& prog);
    void store(const std::string&);
    std::vector<uint8_t> getInsturctions();

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node
        );
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Utilities class for quantum program stored to binary data.

Methods

void transform(QProg& prog)

transform quantum program

Parameters:

QProg&

quantum program

Returns:

void

void store(const std::string&)

Store quantum program data.

Parameters:

const

std::string& filename

Returns:

void

std::vector<uint8_t> getInsturctions()

get quantum program binary data

Returns:

std::vector<uint8_t> quantum program binary data vector

class QPanda::QProgToMatrix

class QPanda::QProgToMatrix::MatrixOfOneLayer

Overview

class MatrixOfOneLayer
{
public:
    // fields

    QProgToMatrix& m_parent;
    qmatrix_t m_current_layer_mat;
    gateQubitInfo_t m_double_qubit_gates;
    gateQubitInfo_t m_single_qubit_gates;
    gateQubitInfo_t m_controled_gates;
    calcUnitVec_t m_calc_unit_vec;
    qmatrix_t m_mat_I;
    std::vector<int>& m_qubits_in_use;

    // construction

    MatrixOfOneLayer(
        QProgToMatrix& parent,
        SeqLayer<pOptimizerNodeInfo>& layer,
        std::vector<int>& qubits_in_use
        );

    // methods

    void merge_double_gate();
    void merge_calc_unit();
    void merge_controled_gate();
    void merge_sing_gate();
};

Detailed Documentation

Fields

gateQubitInfo_t m_double_qubit_gates

double qubit gate vector

gateQubitInfo_t m_single_qubit_gates

single qubit gate vector

gateQubitInfo_t m_controled_gates

controled qubit gate vector

std::vector<int>& m_qubits_in_use

the number of all the qubits in the target QCircuit.

Overview

get the matrix of a QProg More…

#include <QProgToMatrix.h>

class QProgToMatrix
{
public:
    // classes

    class MatrixOfOneLayer;

    // construction

    QProgToMatrix(
        QProg& p,
        const bool b_bid_endian = false
        );

    // methods

    QStat get_matrix();
    qmatrix_t get_matrix_of_one_layer(SeqLayer<pOptimizerNodeInfo>& layer);
};

Detailed Documentation

get the matrix of a QProg

Methods

QStat get_matrix()

calc the matrix of the input QProg

Returns:

QStat the matrix of the input QProg

qmatrix_t get_matrix_of_one_layer(SeqLayer<pOptimizerNodeInfo>& layer)

calc the matrix of nodes in one layer

Parameters:

SeqLayer<pOptimizerNodeInfo>&	layer nodes
QProgDAG&	DAG algorithm object

Returns:

qmatrix_t the matrix of the layer

class QPanda::QProgToOriginIR

Overview

QuantumProg Transform To OriginIR instruction sets. More…

#include <QProgToOriginIR.h>

class QProgToOriginIR: public QPanda::TraversalInterface
{
public:
    // construction

    QProgToOriginIR(QuantumMachine* quantum_machine);

    // methods

    virtual void transform(QProg& prog);

    template <typename _Ty>
    void traversal(_Ty& node);

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node
        );

    virtual std::string getInsturctions();
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

QuantumProg Transform To OriginIR instruction sets.

Methods

virtual void transform(QProg& prog)

Transform quantum program.

Parameters:

QProg&

quantum program

Returns:

void

virtual std::string getInsturctions()

get OriginIR insturction set

Returns:

std::string

class QPanda::QProgToQASM

Overview

Quantum Prog Transform To QASM instruction sets. More…

#include <QProgToQASM.h>

class QProgToQASM: public QPanda::TraverseByNodeIter
{
public:
    // construction

    QProgToQASM(
        QProg src_prog,
        QuantumMachine* quantum_machine
        );

    // methods

    virtual std::string getInsturctions();
    virtual void transform();

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);

Detailed Documentation

Quantum Prog Transform To QASM instruction sets.

Methods

virtual std::string getInsturctions()

get QASM insturction set

Returns:

std::string

virtual void transform()

Transform Quantum program.

Parameters:

QProg&

quantum program

Returns:

void

class QPanda::QProgToQCircuit

Overview

cast QProg to QCircuit More…

#include <QProgToQCircuit.h>

class QProgToQCircuit: public QPanda::TraversalInterface
{
public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuit& circuit
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuit& circuit
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuit& circuit
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuit& circuit
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuit& circuit
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuit& circuit
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuit& circuit
        );
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

cast QProg to QCircuit

Methods

virtual void execute(
    std::shared_ptr<AbstractQGateNode> cur_node,
    std::shared_ptr<QNode> parent_node,
    QCircuit& circuit
    )

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumMeasure> cur_node,
    std::shared_ptr<QNode> parent_node,
    QCircuit& circuit
    )

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumReset> cur_node,
    std::shared_ptr<QNode> parent_node,
    QCircuit& circuit
    )

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractControlFlowNode> cur_node,
    std::shared_ptr<QNode> parent_node,
    QCircuit& circuit
    )

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumCircuit> cur_node,
    std::shared_ptr<QNode> parent_node,
    QCircuit& circuit
    )

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumProgram> cur_node,
    std::shared_ptr<QNode> parent_node,
    QCircuit& circuit
    )

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractClassicalProg> cur_node,
    std::shared_ptr<QNode> parent_node,
    QCircuit& circuit
    )

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class QPanda::QProgToQGate

Overview

cast QProg to QGate More…

#include <QProgToQGate.h>

class QProgToQGate: public QPanda::TraversalInterface
{
public:
    // methods

    virtual void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node);
    std::shared_ptr<AbstractQGateNode> get_qgate();
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

cast QProg to QGate

Methods

virtual void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class QPanda::QProgToQMeasure

Overview

cast QProg to QMeasure More…

#include <QProgToQMeasure.h>

class QProgToQMeasure: public QPanda::TraversalInterface
{
public:
    // methods

    virtual void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node);
    std::shared_ptr<AbstractQuantumMeasure> get_qmeasure();
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

cast QProg to QMeasure

Methods

virtual void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class QPanda::QProgToQuil

Overview

QuantumProg Transform To Quil instruction sets. More…

#include <QProgToQuil.h>

class QProgToQuil: public QPanda::TraversalInterface
{
public:
    // construction

    QProgToQuil(QuantumMachine* quantum_machine);

    // methods

    virtual void transform(QProg& prog);
    virtual std::string getInsturctions();
    void transformQProgByTraversalAlg(QProg* prog);

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

QuantumProg Transform To Quil instruction sets.

Methods

virtual void transform(QProg& prog)

transform quantum program

Parameters:

QProg&

quantum program

Returns:

void

virtual std::string getInsturctions()

get Quil insturction set

Returns:

std::string

void transformQProgByTraversalAlg(QProg* prog)

Transform Quantum program by Traversal algorithm, refer to class Traversal.

Parameters:

QProg&

quantum program

Returns:

void

class QPanda::QRunesToQProg

Transform QRunes instruction set To Quantum program.

#include <QRunesToQProg.h>

class QRunesToQProg
{
public:
    // fields

    QuantumMachine* qvm;
    std::vector<ClassicalCondition> m_cbit_vec;

    // methods

    void qRunesParser(
        std::string,
        QProg&,
        QuantumMachine*
        );
};

class QPanda::QScheduler

struct QPanda::QScheduler::LogicalGate

Overview

logical gate More…

#include <QScheduler.h>

struct LogicalGate
{
    // fields

    int t;
    int c;
    std::string gate;
    int gate_type;
    bool is_dagger;
    std::vector<double> param;
    int barrier_id;

    // construction

    LogicalGate(
        std::string gate,
        int gate_type,
        int c,
        int t,
        std::vector<double> param,
        int barrier_id,
        bool is_dagger
        );

    // methods

    bool isSingleQubitGate() const;
};

Detailed Documentation

logical gate

Fields

int t

index of the target qubit

int c

index of the control qubit, c = -1 for single qubit gate

std::string gate

type of the gate

int gate_type

these parameters can be encapsulated

Construction

LogicalGate(
    std::string gate,
    int gate_type,
    int c,
    int t,
    std::vector<double> param,
    int barrier_id,
    bool is_dagger
    )

create a gate

struct QPanda::QScheduler::PhysicsGate

Overview

physical gate More…

#include <QScheduler.h>

struct PhysicsGate
{
    // fields

    std::string type;
    int gate_type;
    bool is_dagger;
    std::vector<double> param;
    bool is_apply_swap;
    int i1;
    int j1;
    int i2;
    int j2;
    int barrier_id;

    // methods

    bool isSwapGate();
    bool isControlGate();
};

Detailed Documentation

physical gate

Fields

int j1

(i1, j1) is the position for the first qubit parament of the gate

int j2

(i2, j2) is the position for the first qubit parament of the two-qubit gate

Overview

CODAR algorithm, used for mapping calculations. More…

#include <QScheduler.h>

class QScheduler
{
public:
    // structs

    struct LogicalGate;
    struct PhysicsGate;

    // fields

    std::vector<int> map_list;
    BasicGridDevice* device;
    std::vector<GateInfo> mapped_result_gates;
    std::list<LogicalGate> logical_gate_list;
    std::list<LogicalGate> candidate_gates;
    int gate_count = 0;
    int swap_gate_count = 0;
    std::map<std::pair<int, int>, std::pair<int, double>> candidate_swaps;
    std::map<int, int> logical_qubit_apply_degree;
    std::vector<double> physics_gate_fidelity;
    std::vector<std::vector<double>> physics_qubit_error;
    double double_gate_error_rate = 0;

    // construction

    QScheduler(BasicGridDevice* device);

    // methods

    void loadCommutingTable();
    size_t getLogicalQubitCount();
    int addLogicalQubit(int i, int j);
    bool addLogicalQubits(int count, bool is_order = false);

    void addSingleQubitGate(
        std::string gate,
        int gate_type,
        int t,
        std::vector<double> param,
        int barrier_id = -1,
        bool is_dagger = false
        );

    void addDoubleQubitGate(
        std::string gate,
        int gate_type,
        int c,
        int t,
        std::vector<double> param,
        bool is_dagger = false
        );

    void start();

    void setQubitFidelity(
        std::map<int, int> degree,
        std::vector<double> fidelity,
        std::vector<std::vector<double>> error_rate
        );
};

Detailed Documentation

CODAR algorithm, used for mapping calculations.

Fields

std::vector<int> map_list

the mapping table from logical qubits to physical qubits, see getMappedPosition

BasicGridDevice* device

the device

std::vector<GateInfo> mapped_result_gates

the output

std::list<LogicalGate> logical_gate_list

the list of logical gates (the whole circuit)

std::list<LogicalGate> candidate_gates

the set of Commutative Forward gates

int gate_count = 0

count of gates launched

std::map<std::pair<int, int>, std::pair<int, double>> candidate_swaps

maps from candidate swaps to their heuristic costs

Methods

size_t getLogicalQubitCount()

get count of logical qubits

int addLogicalQubit(int i, int j)

add a logical qubit by its position return the index of the logical qubit

bool addLogicalQubits(int count, bool is_order = false)

add several logical qubits and make initial mapping automaticly

MUST ENSURE YOU HAVEN”T MAPPED ANY QUBIT BEFORE CALLING

Parameters:

int	count of qubits

Returns:

bool true if success

void addSingleQubitGate(
    std::string gate,
    int gate_type,
    int t,
    std::vector<double> param,
    int barrier_id = -1,
    bool is_dagger = false
    )

add a (logical) single qubit gate

void addDoubleQubitGate(
    std::string gate,
    int gate_type,
    int c,
    int t,
    std::vector<double> param,
    bool is_dagger = false
    )

add a logical double qubit gate

void start()

start remapping (call it after intialization) , The main entry of the CODAR remapper

class QPanda::QString

enum QPanda::QString::BaseCovert

#include <QString.h>

enum BaseCovert
{
    BIN,
    DEC,
    HEX,
};

enum QPanda::QString::SplitBehavior

#include <QString.h>

enum SplitBehavior
{
    KeepEmptyParts,
    SkipEmptyParts,
};

QString.

#include <QString.h>

class QString
{
public:
    // enums

    enum BaseCovert;
    enum SplitBehavior;

    // construction

    QString();
    QString(char c);
    QString(const char* s);

    QString(
        const char* s,
        size_t n
        );

    QString(
        size_t n,
        char c
        );

    QString(const std::string& str);

    QString(
        const std::string& str,
        size_t pos,
        size_t len = std::string::npos
        );

    template <class InputIterator>
    QString(
        InputIterator first,
        InputIterator last
        );

    QString(std::string&& str);
    QString(const QString& str);
    QString(QString&& str);

    // methods

    QString& operator = (const char* s);
    QString& operator = (const std::string& str);
    QString& operator = (const QString& str);
    size_t size() const;
    bool isEmpty() const;

    size_t find(
        const QString& sub_str,
        size_t pos = 0
        ) const;

    char at(size_t i) const;
    char operator [] (size_t i) const;
    char front() const;
    char back() const;
    QString left(size_t n) const;
    QString right(size_t n) const;

    QString mid(
        size_t pos,
        size_t n = std::string::npos
        ) const;

    std::vector<QString> split(
        const QString& sep,
        SplitBehavior behavior = KeepEmptyParts
        ) const;

    std::vector<QString> splitByStr(
        const QString& sep,
        SplitBehavior behavior = KeepEmptyParts
        ) const;

    QString trimmed() const;
    QString toUpper() const;
    QString toLower() const;

    int toInt(
        bool* ok = nullptr,
        BaseCovert base = DEC
        ) const;

    float toFloat(bool* ok = nullptr) const;
    double toDouble(bool* ok = nullptr) const;
    const std::string& data() const;
    bool operator == (const char* s) const;
    bool operator != (const char* s) const;
    bool operator < (const char* s) const;
    bool operator > (const char* s) const;
    bool operator <= (const char* s) const;
    bool operator >= (const char* s) const;
    bool operator == (const std::string& s) const;
    bool operator != (const std::string& s) const;
    bool operator < (const std::string& s) const;
    bool operator > (const std::string& s) const;
    bool operator <= (const std::string& s) const;
    bool operator >= (const std::string& s) const;
};

class QPanda::QuantumMetadata

Parse xml config and get metadata.

#include <QuantumMetadata.h>

class QuantumMetadata
{
public:
    // construction

    QuantumMetadata(const std::string& filename = CONFIG_PATH);

    // methods

    QuantumMetadata& operator = (const QuantumMetadata&);

    bool getMetadata(
        int& qubit_num,
        std::vector<std::vector<double>>& matrix
        );

    bool getQGate(
        std::vector<std::string>& single_gates,
        std::vector<std::string>& double_gates
        );

    bool getGateTime(std::map<GateType, size_t>& gate_time_map);
};

class QPanda::QuantumVolume

struct QPanda::QuantumVolume::QvCircuit

struct QvCircuit
{
    // fields

    QProg cir;
    int depth;
    int trial;
    QVec qv;
    std::vector<ClassicalCondition> cv;
    prob_vec result;
    float heavy_output;
    int shots;
    int qvm_type;
};

Calculate the quantum volume of the chip.

#include <QuantumVolume.h>

class QuantumVolume
{
public:
    // structs

    struct QvCircuit;

    // construction

    QuantumVolume(
        MeasureQVMType type,
        QuantumMachine* qvm
        );

    // methods

    size_t calcQuantumVolume(
        const std::vector<std::vector<int>>& qubit_lists,
        int ntrials,
        int shots
        );
};

class QPanda::RandomCircuit

struct QPanda::RandomCircuit::QubitInformation

#include <RandomCircuit.h>

struct QubitInformation
{
    // fields

    int x = 0;
    int y = 0;
    bool has_T = false;
    int gate_type = 0;
};

Generate random quantum circuit.

#include <RandomCircuit.h>

class RandomCircuit
{
public:
    // typedefs

    typedef std::vector<std::vector<QubitInformation>> LayerInfo;
    typedef std::function<bool(int, int, LayerInfo&)> SetLayerFunc;

    // structs

    struct QubitInformation;

    // construction

    RandomCircuit(
        QuantumMachine* qvm,
        QVec& qv
        );

    // methods

    void random_circuit(
        int qbitRow,
        int qbitColumn,
        int depth
        );

    std::string get_random_originir();
    QProg get_random_qprog();
};

class QPanda::RandomizedBenchmarking

struct QPanda::RandomizedBenchmarking::Cliffords

#include <RandomizedBenchmarking.h>

struct Cliffords
{
    // fields

    CliffordsSeq c1_in_xy;
    CliffordsSeq c1_in_xz;
    CliffordsSeq s1;
    CliffordsSeq s1_x;
    CliffordsSeq s1_y;
};

#include <RandomizedBenchmarking.h>

class RandomizedBenchmarking
{
public:
    // typedefs

    typedef std::vector<std::vector<std::shared_ptr<RBGate>>> CliffordsSeq;

    // structs

    struct Cliffords;

    // construction

    RandomizedBenchmarking(
        MeasureQVMType type,
        QuantumMachine* qvm
        );

    // methods

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

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

class ReadLock

Read Lock.

#include <ReadWriteLock.h>

class ReadLock
{
public:
    // construction

    ReadLock(SharedMutex& sm);
};

class QPanda::RemapQProg

remap a QProg to new qubits

#include <RemapQProg.h>

class RemapQProg: public QPanda::TraverseByNodeIter
{
public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    QProg remap(
        QProg src_prog,
        QVec target_qv,
        std::vector<ClassicalCondition> target_cv
        );

    const std::map<size_t, Qubit*>& get_qubit_map() const;
    const std::map<size_t, ClassicalCondition>& get_cbit_map() const;
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);

class QPanda::SU4TopologyMatch

struct QPanda::SU4TopologyMatch::gate

Store quantum gate information.

struct gate
{
    // fields

    int target;
    int control;
    int type;
    bool is_dagger;
    bool is_flip;
    std::vector<double> param;
};

struct QPanda::SU4TopologyMatch::gates_digraph

Overview

Simple digraph, used to group all gates. More…

struct gates_digraph
{
    // fields

    std::map<size_t, std::pair<std::vector<gate>, std::vector<int>>> vertexs;
    std::vector<std::pair<size_t, size_t>> edges;
    size_t id = 0;

    // methods

    size_t add_vertex(std::pair<std::vector<gate>, std::vector<int>> info);

    bool add_edge(
        size_t u,
        size_t v
        );

    bool remove_vertex(size_t id);
    size_t in_degree(size_t id);
};

Detailed Documentation

Simple digraph, used to group all gates.

Fields

std::vector<std::pair<size_t, size_t>> edges

in –> out

struct QPanda::SU4TopologyMatch::node

Overview

define struct for nodes in the A* search; More…

struct node
{
    // fields

    int cost_fixed;
    int cost_heur;
    std::vector<int> locations;
    std::vector<int> qubits;
    bool is_goal;
    std::vector<std::pair<int, int>> swaps;
    std::vector<std::pair<int, int>> remaining_gates;
};

Detailed Documentation

define struct for nodes in the A* search;

Fields

int cost_fixed

fixed cost of the current permutation

std::vector<int> locations

heuristic cost of the current permutation

std::vector<int> qubits

location (i.e. pysical qubit) of a logical qubit

bool is_goal

logical qubits that are mapped to the physical ones

std::vector<std::pair<int, int>> swaps

true if the node is a goal node;

std::vector<std::pair<int, int>> remaining_gates

a sequence of swap operations that have been applied

struct QPanda::SU4TopologyMatch::node_cmp

define struct for priority queue

struct node_cmp
{
    // methods

    bool operator () (
        node& x,
        node& y
        ) const;
};

Overview

Su4 quantum circuit matches the topology of the physical qubits. More…

#include <SU4TopologyMatch.h>

class SU4TopologyMatch
{
public:
    // structs

    struct gate;
    struct gates_digraph;
    struct node;
    struct node_cmp;

    // construction

    SU4TopologyMatch(
        QuantumMachine* machine,
        QVec& qv,
        ArchType arch_type = IBM_QX5_ARCH
        );

    // methods

    void mapping_qprog(QProg prog, QProg& mapped_prog);
};

Detailed Documentation

Su4 quantum circuit matches the topology of the physical qubits.

Methods

void mapping_qprog(QProg prog, QProg& mapped_prog)

Mapping qubits in a quantum program.

Parameters:

Qprog	quantum program
Qprog&	the mapped quantum program

Returns:

void

class SharedMutex

Shared Mutex.

#include <ReadWriteLock.h>

class SharedMutex
{
public:
    // methods

    void read();
    void unread();
    void write();
    void unwrite();
};

class QPanda::SimpleGridDevice

Overview

A derived class of BasicGridDevice The two qubits are adjacent when their Manhattan distance is 1. More…

#include <GridDevice.h>

class SimpleGridDevice: public QPanda::BasicGridDevice
{
public:
    // construction

    SimpleGridDevice(
        int m,
        int n
        );

    // methods

    virtual bool isNearBy(int i1, int j1, int i2, int j2);
    virtual int getDistance(int i1, int j1, int i2, int j2);
};

// direct descendants

class UncompletedGridDevice;

Inherited Members

public:
    // structs

    struct PhysicalQubit;

    // methods

    void clear();
    int getM();
    int getN();
    auto& getQubit(int i, int j);
    bool canApplyGate(int i1, int j1, int i2, int j2, int);
    bool canApplyGate(int i, int j, int);
    bool canSwap(int i1, int j1, int i2, int j2);
    void applySingleGate(int i, int j);
    void applyGate(int i1, int j1, int i2, int j2, int time);
    void applyDoubleGate(int i1, int j1, int i2, int j2);
    void applySwap(int i1, int j1, int i2, int j2);
    virtual bool isNearBy(int i1, int j1, int i2, int j2) = 0;
    virtual int getDistance(int i1, int j1, int i2, int j2) = 0;
    void map(int dest, int i, int j);
    void resetTime();
    void nextCycle();
    int maxTime();
    int getTime();
    bool isQubitFree(int i, int j);
    bool isAllQubitFree();
    bool isSimpleGridDevice();
    bool isSupportSwapGate();

Detailed Documentation

A derived class of BasicGridDevice The two qubits are adjacent when their Manhattan distance is 1.

Methods

virtual bool isNearBy(int i1, int j1, int i2, int j2)

Check if two qubits are adjacent, location of qubits are (i1, j1) and (i2, j2)

virtual int getDistance(int i1, int j1, int i2, int j2)

get distance+1 of two qubits

class QPanda::SingleGateTypeValidator

Get single gate metadata Validator type.

#include <MetadataValidity.h>

class SingleGateTypeValidator
{
public:
    // fields

    MetadataValidity m_metadata_validity_functions;

    // methods

    static int GateType(
        std::vector<std::string>& gates,
        std::vector<std::string>& valid_gates
        );
};

class QPanda::TimeSequenceConfig

Time Sequence Config.

#include <JsonConfigParam.h>

class TimeSequenceConfig
{
public:
    // methods

    void load_config(const std::string config_data = CONFIG_PATH);
    int get_measure_time_sequence();
    int get_ctrl_node_time_sequence();
    int get_swap_gate_time_sequence();
    int get_single_gate_time_sequence();
    int get_reset_time_sequence();

    int read_config(
        const char* config_type_str,
        int val
        );
};

class QPanda::TopologyMatch

struct QPanda::TopologyMatch::edge

struct edge
{
    // fields

    int v1;
    int v2;

    // methods

    bool operator < (const struct edge& right) const;
};

struct QPanda::TopologyMatch::gate

struct gate
{
    // fields

    int target;
    int control;
    int type;
    bool is_dagger;
    bool is_flip;
    std::vector<double> param;
};

struct QPanda::TopologyMatch::node

struct node
{
    // fields

    int cost_fixed;
    int cost_heur;
    int cost_heur2;
    int depth;
    std::vector<int> qubits;
    std::vector<int> locations;
    int nswaps;
    int done;
    std::vector<std::vector<edge>> swaps;
};

struct QPanda::TopologyMatch::node_cmp

struct node_cmp
{
    // methods

    bool operator () (
        node& x,
        node& y
        ) const;
};

Overview

QProg/QCircuit matches the topology of the physical qubits. More…

#include <TopologyMatch.h>

class TopologyMatch: public QPanda::TraversalInterface
{
public:
    // structs

    struct edge;
    struct gate;
    struct node;
    struct node_cmp;

    // construction

    TopologyMatch(
        QuantumMachine* machine,
        QProg prog,
        SwapQubitsMethod method = CNOT_GATE_METHOD,
        ArchType arch_type = IBM_QX5_ARCH,
        const std::string conf = CONFIG_PATH
        );

    // methods

    void mappingQProg(QVec& qv, QProg& mapped_prog);

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        bool&
        );
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

QProg/QCircuit matches the topology of the physical qubits.

Methods

void mappingQProg(QVec& qv, QProg& mapped_prog)

Mapping qubits in a quantum program.

Parameters:

Qprog	quantum program
Qprog&	the mapped quantum program

Returns:

void

class QPanda::TransformByCNOT

swap qubit location by CNOT quantum gate

#include <TopologyMatch.h>

class TransformByCNOT: public QPanda::TransformSwapAlg
{
public:
    // methods

    virtual void transform(
        Qubit* control_qubit,
        Qubit* target_qubit,
        QProg& prog
        );

    virtual int getSwapCost();
    virtual int getFlipCost();
};

Inherited Members

public:
    // methods

    virtual void transform(Qubit* control_qubit, Qubit* target_qubit, QProg& prog) = 0;
    virtual int getSwapCost() = 0;
    virtual int getFlipCost() = 0;

class QPanda::TransformByCZ

swap qubit location by CZ quantum gate

#include <TopologyMatch.h>

class TransformByCZ: public QPanda::TransformSwapAlg
{
public:
    // methods

    virtual void transform(
        Qubit* control_qubit,
        Qubit* target_qubit,
        QProg& prog
        );

    virtual int getSwapCost();
    virtual int getFlipCost();
};

Inherited Members

public:
    // methods

    virtual void transform(Qubit* control_qubit, Qubit* target_qubit, QProg& prog) = 0;
    virtual int getSwapCost() = 0;
    virtual int getFlipCost() = 0;

class QPanda::TransformByISWAP

swap qubit location by ISWAP quantum gate

#include <TopologyMatch.h>

class TransformByISWAP: public QPanda::TransformSwapAlg
{
public:
    // methods

    virtual void transform(
        Qubit* control_qubit,
        Qubit* target_qubit,
        QProg& prog
        );

    virtual int getSwapCost();
    virtual int getFlipCost();
};

Inherited Members

public:
    // methods

    virtual void transform(Qubit* control_qubit, Qubit* target_qubit, QProg& prog) = 0;
    virtual int getSwapCost() = 0;
    virtual int getFlipCost() = 0;

class QPanda::TransformBySWAP

swap qubit location by SWAP quantum gate

#include <TopologyMatch.h>

class TransformBySWAP: public QPanda::TransformSwapAlg
{
public:
    // methods

    virtual void transform(
        Qubit* control_qubit,
        Qubit* target_qubit,
        QProg& prog
        );

    virtual int getSwapCost();
    virtual int getFlipCost();
};

Inherited Members

public:
    // methods

    virtual void transform(Qubit* control_qubit, Qubit* target_qubit, QProg& prog) = 0;
    virtual int getSwapCost() = 0;
    virtual int getFlipCost() = 0;

class QPanda::TransformDecomposition

Overview

Transform and decompose qprog. More…

#include <TransformDecomposition.h>

class TransformDecomposition
{
public:
    // construction

    TransformDecomposition(
        std::vector<std::vector<std::string>>& ValidQGateMatrix,
        std::vector<std::vector<std::string>>& QGateMatrix,
        QuantumMachine* quantum_machine,
        const std::string& config_data = CONFIG_PATH
        );

    // methods

    void TraversalOptimizationMerge(QProg& prog);
    void merge_continue_single_gate_to_u3(QProg& prog);

    void decompose_double_qgate(
        QProg& prog,
        bool b_decompose_multiple_gate = true
        );

    void meta_gate_transform(QProg& prog);
};

Detailed Documentation

Transform and decompose qprog.

Methods

void merge_continue_single_gate_to_u3(QProg& prog)

merge continue single gate to u3 gate

Parameters:

QProg&

the source prog

Returns:

class QPanda::TransformQGateType

Classes for tranform gate type and gate name.

#include <TranformQGateTypeStringAndEnum.h>

class TransformQGateType
{
public:
    // methods

    static TransformQGateType& getInstance();
    std::string operator [] (GateType);
    GateType operator [] (std::string gate_name);
};

class QPanda::TransformSwapAlg

swap qubit location algorithm abstract class

#include <TopologyMatch.h>

class TransformSwapAlg
{
public:
    // methods

    virtual void transform(
        Qubit* control_qubit,
        Qubit* target_qubit,
        QProg& prog
        ) = 0;

    virtual int getSwapCost() = 0;
    virtual int getFlipCost() = 0;
};

// direct descendants

class TransformByCNOT;
class TransformByCZ;
class TransformByISWAP;
class TransformBySWAP;

class QPanda::TransformSwapAlgFactory

swap qubit location algorithm factory

#include <TopologyMatch.h>

class TransformSwapAlgFactory
{
public:
    // methods

    TransformSwapAlg* CreateByType(SwapQubitsMethod type);
    static TransformSwapAlgFactory& GetFactoryInstance();
};

class QPanda::Traversal

Overview

Traversing all the nodes of the linked qprog/qcircuit/control_flow_node. More…

#include <Traversal.h>

class Traversal
{
public:
    // methods

    template <typename T, typename... Args>
    static void traversal(
        std::shared_ptr<AbstractControlFlowNode> control_flow_node,
        T& func_class,
        Args&&... func_args
        );

    template <typename T, typename... Args>
    static void traversal(
        std::shared_ptr<AbstractQuantumCircuit> qcircuit_node,
        bool identify_dagger,
        T& func_class,
        Args&&... func_args
        );

    template <typename T, typename... Args>
    static void traversal(
        std::shared_ptr<AbstractQuantumProgram> qprog_node,
        T& func_class,
        Args&&... func_args
        );

    template <typename T, typename... Args>
    static void traversalByType(
        std::shared_ptr<QNode> node,
        std::shared_ptr<QNode> parent_node,
        T& func_class,
        Args&&... func_args
        );
};

Detailed Documentation

Traversing all the nodes of the linked qprog/qcircuit/control_flow_node.

Methods

template <typename T, typename... Args>
static void traversal(
    std::shared_ptr<AbstractControlFlowNode> control_flow_node,
    T& func_class,
    Args&&... func_args
    )

Traversing qprog control flow circuit.

Parameters:

AbstractControlFlowNode*	Control flow nodes that need to be traversed
TraversalInterface*	The method object needed for traversal

Returns:

void

template <typename T, typename... Args>
static void traversal(
    std::shared_ptr<AbstractQuantumCircuit> qcircuit_node,
    bool identify_dagger,
    T& func_class,
    Args&&... func_args
    )

Traversing qcircuit.

Parameters:

AbstractQuantumCircuit*	QCircuit nodes that need to be traversed
TraversalInterface*	The method object needed for traversal
bool	Whether the quantum circuit needs to be transposed

Returns:

void

template <typename T, typename... Args>
static void traversal(
    std::shared_ptr<AbstractQuantumProgram> qprog_node,
    T& func_class,
    Args&&... func_args
    )

Traversing qprog.

Parameters:

AbstractQuantumProgram*	QProg nodes that need to be traversed
TraversalInterface*	The method object needed for traversal

Returns:

void

template <typename T, typename... Args>
static void traversalByType(
    std::shared_ptr<QNode> node,
    std::shared_ptr<QNode> parent_node,
    T& func_class,
    Args&&... func_args
    )

traversalByType

Parameters:

QNode*	nodes that need to be traversed
parent_node*	nodes that need to be traversed
TraversalInterface*	The method object needed for traversal

Returns:

void

class QPanda::TraversalConfig

Overview

traversal config More…

#include <Traversal.h>

class TraversalConfig
{
public:
    // fields

    size_t m_qubit_number;
    std::map<std::string, bool> m_return_value;
    bool m_is_dagger;
    std::vector<QPanda::Qubit*> m_control_qubit_vector;
    double m_rotation_angle_error { 0 };
    bool m_can_optimize_measure = true;
    std::vector<size_t> m_measure_qubits;
    std::vector<CBit*> m_measure_cc;

    // construction

    TraversalConfig(double rotation_angle_error = 0);
};

Detailed Documentation

traversal config

Fields

size_t m_qubit_number

quantum bit number

std::map<std::string, bool> m_return_value

MonteCarlo result

template class QPanda::TraversalInterface

Overview

All objects that want to use the class Traversal need to integrate this class. More…

#include <Traversal.h>

template <typename... Args>
class TraversalInterface
{
public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );
};

// direct descendants

class CancelControlQubitVector;
class DecomposeControlSingleQGateIntoMetadataDoubleQGate;
class DecomposeControlUnitarySingleQGate;
class DecomposeDoubleQGate;
class DecomposeMultipleControlQGate;
class DecomposeUnitarySingleQGateIntoMetadataSingleQGate;
class DeleteUnitQNode;
class MergeSingleGate;
class MPSQVM;
class NoiseSimulator;
class PartialAmplitudeQVM;
class QCodarMatch;
class QGateCompare;
class QGateCounter;
class QNodeDeepCopy;
class QProgFlattening;
class QProgStored;
class QProgToOriginIR;
class QProgToQCircuit;
class QProgToQGate;
class QProgToQMeasure;
class QProgToQuil;
class SingleAmplitudeQVM;
class TopologyMatch;
class TraverseByNodeIter;

Detailed Documentation

All objects that want to use the class Traversal need to integrate this class.

Methods

virtual void execute(
    std::shared_ptr<AbstractQGateNode> cur_node,
    std::shared_ptr<QNode> parent_node,
    Args&&... func_args
    )

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
QNode*	parent Node

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumMeasure> cur_node,
    std::shared_ptr<QNode> parent_node,
    Args&&... func_args
    )

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
QNode*	parent Node

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumReset> cur_node,
    std::shared_ptr<QNode> parent_node,
    Args&&... func_args
    )

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
QNode*	parent Node

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractControlFlowNode> cur_node,
    std::shared_ptr<QNode> parent_node,
    Args&&... func_args
    )

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
QNode*	parent Node

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumCircuit> cur_node,
    std::shared_ptr<QNode> parent_node,
    Args&&... func_args
    )

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
QNode*	parent Node

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractQuantumProgram> cur_node,
    std::shared_ptr<QNode> parent_node,
    Args&&... func_args
    )

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
QNode*	parent Node

Returns:

void

virtual void execute(
    std::shared_ptr<AbstractClassicalProg> cur_node,
    std::shared_ptr<QNode> parent_node,
    Args&&... func_args
    )

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	classical prog
QNode*	parent Node

Returns:

void

class QPanda::TraverseByNodeIter

Overview

Traverse QProg By NodeIter. More…

#include <QCircuitInfo.h>

class TraverseByNodeIter: public QPanda::TraversalInterface
{
public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);
};

// direct descendants

class AdjacentQGates;
class GetAllNodeType;
class GetAllUsedQubitAndCBit;
class JudgeTwoNodeIterIsSwappable;
class PickUpNodes;
class ProcessOnTraversing;
class QProgToDAG;
class QProgToQASM;
class RemapQProg;

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Traverse QProg By NodeIter.

Methods

virtual void traverse_qprog(QProg prog)

start traverse a quantum prog

class QPanda::UncompletedGridDevice

UncompletedGridDevice is a derived class of SimpleGridDevice Compared with SimpleGridDevice, some qubits are NOT AVAILABLE, but the adjacent relation is the same e.g. google Sycamore q54.

#include <GridDevice.h>

class UncompletedGridDevice: public QPanda::SimpleGridDevice
{
public:
    // construction

    UncompletedGridDevice(
        int m,
        int n,
        const bool* available_qubits
        );

    // methods

    void resetAvailableQubits(const bool* available_qubits);

    bool isQubitAvailable(
        int i,
        int j
        );
};

Inherited Members

public:
    // structs

    struct PhysicalQubit;

    // methods

    void clear();
    int getM();
    int getN();
    auto& getQubit(int i, int j);
    bool canApplyGate(int i1, int j1, int i2, int j2, int);
    bool canApplyGate(int i, int j, int);
    bool canSwap(int i1, int j1, int i2, int j2);
    void applySingleGate(int i, int j);
    void applyGate(int i1, int j1, int i2, int j2, int time);
    void applyDoubleGate(int i1, int j1, int i2, int j2);
    void applySwap(int i1, int j1, int i2, int j2);
    virtual bool isNearBy(int i1, int j1, int i2, int j2) = 0;
    virtual int getDistance(int i1, int j1, int i2, int j2) = 0;
    void map(int dest, int i, int j);
    void resetTime();
    void nextCycle();
    int maxTime();
    int getTime();
    bool isQubitFree(int i, int j);
    bool isAllQubitFree();
    bool isSimpleGridDevice();
    bool isSupportSwapGate();
    virtual bool isNearBy(int i1, int j1, int i2, int j2);
    virtual int getDistance(int i1, int j1, int i2, int j2);

class WriteLock

Write Lock.

#include <ReadWriteLock.h>

class WriteLock
{
public:
    // construction

    WriteLock(SharedMutex& sm);
};

class QPanda::init_fail

QPanda2 init failed exception.

#include <QPandaException.h>

class init_fail: public QPanda::QPandaException
{
public:
    // construction

    init_fail();
    init_fail(std::string errmsg);
};

Inherited Members

public:
    // methods

    virtual const char* what();

class QPanda::qalloc_fail

Overview

QPanda2 alloc qubit failed exception. More…

#include <QPandaException.h>

class qalloc_fail: public QPanda::QPandaException
{
public:
    // construction

    qalloc_fail();
    qalloc_fail(std::string errmsg);
};

Inherited Members

public:
    // methods

    virtual const char* what();

Detailed Documentation

QPanda2 alloc qubit failed exception.

QPanda2 alloc cbit failed exception.

class QPanda::qcircuit_construction_fail

QPanda2 qcircuit construction failed exception.

#include <QPandaException.h>

class qcircuit_construction_fail: public QPanda::QPandaException
{
public:
    // construction

    qcircuit_construction_fail();
    qcircuit_construction_fail(std::string err);
};

Inherited Members

public:
    // methods

    virtual const char* what();

class QPanda::qprog_construction_fail

QPanda2 quantum program construction failed exception.

#include <QPandaException.h>

class qprog_construction_fail: public QPanda::QPandaException
{
public:
    // construction

    qprog_construction_fail();
    qprog_construction_fail(std::string err);
};

Inherited Members

public:
    // methods

    virtual const char* what();

class QPanda::qprog_syntax_error

QPanda2 quantum program syntax error exception.

#include <QPandaException.h>

class qprog_syntax_error: public QPanda::QPandaException
{
public:
    // construction

    qprog_syntax_error();
    qprog_syntax_error(std::string err);
};

Inherited Members

public:
    // methods

    virtual const char* what();

class QPanda::qvm_attributes_error

QPanda2 quantum machine attributes error exception.

#include <QPandaException.h>

class qvm_attributes_error: public QPanda::QPandaException
{
public:
    // construction

    qvm_attributes_error();
    qvm_attributes_error(std::string err);
};

Inherited Members

public:
    // methods

    virtual const char* what();

class QPanda::result_get_fail

Overview

QPanda2 get result failed exception. More…

#include <QPandaException.h>

class result_get_fail: public QPanda::QPandaException
{
public:
    // construction

    result_get_fail(std::string cls);
};

Inherited Members

public:
    // methods

    virtual const char* what();

Detailed Documentation

QPanda2 get result failed exception.

QPanda2 alloc quantum gate failed exception.

class QPanda::run_fail

QPanda2 running time error exception.

#include <QPandaException.h>

class run_fail: public QPanda::QPandaException
{
public:
    // construction

    run_fail(std::string cls);
};

Inherited Members

public:
    // methods

    virtual const char* what();

class QPanda::undefine_error

QPanda2 undefined error exception.

#include <QPandaException.h>

class undefine_error: public QPanda::QPandaException
{
public:
    // construction

    undefine_error();
    undefine_error(std::string err);
};

Inherited Members

public:
    // methods

    virtual const char* what();

Overview

// typedefs

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

// structs

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

// classes

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

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

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

// global functions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Detailed Documentation

Typedefs

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

Apply Quantum Gate on a series of Qubit.

Parameters:

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

Returns:

QCircuit

Global Functions

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

OriginIR Transform To Quantum Program.

Parameters:

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

Returns:

QProg quantum program

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

Convert OriginIR To Quantum Program.

Parameters:

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

Returns:

QProg quantum program

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

Convert OriginIR To Quantum Program.

Parameters:

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

Returns:

QProg quantum program

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

Convert OriginIR String To Quantum Program.

Parameters:

std::string	OriginIR String
QuantumMachine*	quantum machine pointer

Returns:

QProg quantum program

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

Convert OriginIR String To Quantum Program.

Parameters:

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

Returns:

QProg quantum program

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

QASM Transform To Quantum Program.

Parameters:

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

Returns:

QProg quantum program

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

QASM Transform To Quantum Program.

Parameters:

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

Returns:

QProg quantum program

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

QASM Transform To Quantum Program.

Parameters:

std::string	QASM string
QuantumMachine*	quantum machine pointer

Returns:

QProg quantum program

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

QASM Transform To Quantum Program.

Parameters:

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

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

Parse quantum program interface for binary data vector.

Parameters:

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

Returns:

bool

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

Parse quantum program interface for binary file.

Parameters:

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

Returns:

bool

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

Parse quantum program interface for binary data vector.

Parameters:

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

Returns:

bool

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

Parse quantum program interface for binary file.

Parameters:

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

Returns:

bool

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

Get quantum program binary data.

Parameters:

QProg&	quantum program
QuantumMachine&	quantum

Returns:

std::vector<uint8_t> quantum program binary data

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

Store quantum program in binary file.

Parameters:

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

Returns:

void

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

Get quantum program binary data.

Parameters:

QProg&	quantum program
QuantumMachine&	quantum

Returns:

std::vector<uint8_t> quantum program binary data

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

Store quantum program in binary file.

Parameters:

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

Returns:

void

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

Quantum Program Transform To OriginIR

Parameters:

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

Returns:

std::string OriginIR instruction set

See also:

  init(QuantumMachine_type::CPU);

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

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

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

Convert Quantum Program To OriginIR.

Parameters:

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

Returns:

std::string OriginIR instruction set

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

write prog to originir file

Parameters:

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

Returns:

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

Convert Quantum program to QASM instruction set.

Parameters:

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

Returns:

std::string QASM instruction set

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

write prog to qasm file

Parameters:

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

Returns:

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

Quantum program transform to quil instruction set interface.

Parameters:

QProg&	quantum program
QuantumMachine*	quantum machine pointer

Returns:

std::string instruction set

See also:

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

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

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

Quantum program transform to quil instruction set interface.

Parameters:

QProg&	quantum program
QuantumMachine*	quantum machine pointer

Returns:

std::string instruction set

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

QRunes instruction set transform to quantum program interface.

Parameters:

QProg&

empty quantum program

Returns:

void

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

Quantum chip adaptive conversion.

Parameters:

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

Returns:

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

Judge if the metadata’s type is arbitrary rotation.

Parameters:

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

Returns:

Return the style of metadata validity

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

Judge if the metadata’s type is double continuous.

Parameters:

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

Returns:

Return the style of metadata validity

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

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

Parameters:

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

Returns:

Return the style of metadata validity

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

Judge if the metadata’s type is double discrete.

Parameters:

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

Returns:

Return the style of metadata validity

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

Judge double gate type.

Parameters:

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

Returns:

Return the style of metadata validity

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

Verify the validity of single quantum gates.

Parameters:

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

Returns:

int single quantum gate type

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

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

Parameters:

vector<vector<double>>&

the target topologic structure of quantum circuit

Returns:

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

See also:

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

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

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

Parameters:

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

Returns:

result string.

See also:

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

judge the specialed two NodeIters whether can be exchanged

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

Parameters:

nodeItr1	the first NodeIter
nodeItr2	the second NodeIter

Returns:

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

bool QPanda::isSupportedGateType(const NodeIter& nodeItr)

judge if the target node is a base QGate type

Parameters:

nodeItr

the target NodeIter

Returns:

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

See also:

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

get the target matrix between the input two Nodeiters

Parameters:

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

Returns:

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

See also:

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

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

Parameters:

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

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

Get all the used quantum bits in the input prog.

Parameters:

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

Returns:

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

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

Get all the used class bits in the input prog.

Parameters:

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

Returns:

return the size of used class bits

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

Get all the measure-info in the input prog.

Parameters:

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

Returns:

return the size of measure-info

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

output all the node type of the target prog

Parameters:

the	target prog

Returns:

return the output string

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

get gate parameter

Parameters:

pGate	the target gate pointer
para_str	parameter string

Returns:

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

Check if it is a valid dagger.

Parameters:

bool

Returns:

bool true for valid dagger

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

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

Parameters:

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

Returns:

size_t Quantum gate num

See also:

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

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

finalize();

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

Get quantum program clock cycle.

Parameters:

QProg	& quantum program
QuantumMachine*	quantum machine pointer

See also:

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

finalize();

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

Get quantum program clock cycle.

Parameters:

QProg	& quantum program
QuantumMachine*	quantum machine pointer

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

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

All the output characters are UTF-8 encoded.

Parameters:

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

Returns:

the output string

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

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

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

Parameters:

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

Returns:

the output string

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

Overload operator <<.

Parameters:

std::ostream&	ostream
QProg	quantum program

Returns:

std::ostream

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

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

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

eg: m = 2, n = 4

Parameters:

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

Returns:

QProg mapped quantum program

Variational

class QPanda::Variational::Double

Double variate.

#include <DataType.h>

class Double
{
public:
    // construction

    Double();
    Double(double val);
    Double(const Double& d);

    // methods

    operator double ();
};

class QPanda::Variational::Optimizer

Optimizer base class.

#include <Optimizer.h>

class Optimizer
{
public:
    // construction

    Optimizer(
        var lost_function,
        double learning_rate = 0.01
        );

    // methods

    virtual std::unordered_set<var> get_variables() = 0;
    virtual std::unordered_map<var, MatrixXd> compute_gradients(std::unordered_set<var>& var_set) = 0;
    virtual double get_loss() = 0;

    virtual bool run(
        std::unordered_set<var>& leaves,
        size_t t = 0
        ) = 0;
};

// direct descendants

class AdaGradOptimizer;
class AdamOptimizer;
class MomentumOptimizer;
class RMSPropOptimizer;
class VanillaGradientDescentOptimizer;

class QPanda::complex_var

complex number variate

#include <complex_var.h>

class complex_var
{
public:
    // construction

    complex_var();
    complex_var(const var& value);

    complex_var(
        const var& v1,
        const var& v2
        );

    // methods

    var real();
    var imag();
    const complex_var operator + (const complex_var& value);
    const complex_var operator - (const complex_var& value);
    const complex_var operator * (const complex_var& value);
    const complex_var operator/ (const complex_var& value);
};

class QPanda::Variational::expression

Overview

A proxy class for the Variational::var. More…

#include <expression.h>

class expression
{
public:
    // construction

    expression(var root);

    // methods

    var getRoot() const;
    std::vector<var> findLeaves();
    MatrixXd propagate();
    MatrixXd propagate(const std::vector<var>& leaves);
    std::unordered_set<var> findNonConsts(const std::vector<var>&);
    std::unordered_set<var> findNonConsts(const std::unordered_set<var>&);
    void backpropagate(std::unordered_map<var, MatrixXd>& leaves);

    void backpropagate(
        std::unordered_map<var, MatrixXd>& leaves,
        const std::unordered_set<var>& nonconsts
        );

    std::unordered_set<var> findVariables();
};

Detailed Documentation

A proxy class for the Variational::var.

Construction

expression(var root)

Construct a new expression object.

Parameters:

root	the root variable, denoting the y in dy/dx.

Methods

var getRoot() const

Get the root.

Returns:

var the root, denoting the y in dy/dx.

std::vector<var> findLeaves()

recursively finding the leaves for the root

Returns:

std::vector<var> the vector of the leaves

MatrixXd propagate()

feed forward the expression, return the value

Returns:

MatrixXd The result

MatrixXd propagate(const std::vector<var>& leaves)

feed forward the expression with given leaves

Parameters:

leaves

leaves either generated by expression::findLeaves or assigned by user (usually not including the training data placeholders).

Returns:

MatrixXd The reuslts.

std::unordered_set<var> findNonConsts(const std::vector<var>&)

find all non-constants variable for the given leaves. if there is some variable not related in the path from the root to the leaves, it will not be added into the set

Returns:

std::unordered_set<var> All non-constants variables.

void backpropagate(std::unordered_map<var, MatrixXd>& leaves)

backpropagation and evalute all gradients.

Parameters:

leaves

The var-grad map. This function will update the gradients.

void backpropagate(
    std::unordered_map<var, MatrixXd>& leaves,
    const std::unordered_set<var>& nonconsts
    )

backpropagation and evalute all gradients.

Parameters:

leaves	The var-grad map. This function will update the gradients.
nonconsts	all non-constants. using this to remove unnecessary nodes from the gradient-evaluation.

QPanda2 variate.

// classes

class QPanda::Variational::Double;
class QPanda::Variational::Optimizer;
class QPanda::complex_var;
class QPanda::Variational::expression;

VirtualQuantumProcessor

class AbstractDistributedFullAmplitudeEngine

Distributed full amplitude engine abstract class.

#include <AbstractFullAmplitudeEngine.h>

class AbstractDistributedFullAmplitudeEngine
{
public:
    // methods

    virtual void initState(
        int head_rank,
        int rank_size,
        int qubit_num
        ) = 0;

    virtual QStat getQState() = 0;

    virtual void singleQubitOperation(
        const int& iQn,
        QStat U,
        bool isConjugate
        ) = 0;

    virtual void controlsingleQubitOperation(
        const int& iQn,
        Qnum& qnum,
        QStat U,
        bool isConjugate
        ) = 0;

    virtual void doubleQubitOperation(
        const int& iQn1,
        const int& iQn2,
        QStat U,
        bool isConjugate
        ) = 0;

    virtual void controldoubleQubitOperation(
        const int& iQn1,
        const int& iQn2,
        Qnum& qnum,
        QStat U,
        bool isConjugate
        ) = 0;

    virtual int measureQubitOperation(const int& qn) = 0;

    virtual void PMeasureQubitOperation(
        Qnum& qnum,
        prob_vec& mResult
        ) = 0;

    virtual void reset_qubit_operation(const int& qn) = 0;
};

class AbstractQuantumGates

Quantum Gates Abstract Class.

#include <QPUImpl.h>

class AbstractQuantumGates
{
public:
    // methods

    virtual QError DiagonalGate(
        Qnum& vQubit,
        QStat& matrix,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError controlDiagonalGate(
        Qnum& vQubit,
        QStat& matrix,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError Reset(size_t qn) = 0;

    virtual QError Hadamard(
        size_t qn,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError Hadamard(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError X(
        size_t qn,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError X(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError P0(
        size_t qn,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError P0(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError P1(
        size_t qn,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError P1(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError Y(
        size_t qn,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError Y(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError Z(
        size_t qn,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError Z(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError T(
        size_t qn,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError T(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError S(
        size_t qn,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError S(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError U1_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError RX_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError RX_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError RY_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError RY_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError RZ_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError RZ_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError CNOT(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError CNOT(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError CR(
        size_t qn_0,
        size_t qn_1,
        double theta,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError CR(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError CZ(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError CZ(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        double theta,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError SqiSWAP(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        ) = 0;

    virtual QError SqiSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        ) = 0;
};

class CPUImplQPU

Overview

QPU implementation by CPU model. More…

#include <CPUImplQPU.h>

class CPUImplQPU: public QPUImpl
{
public:
    // fields

    vQParam qubit2stat;
    vQParam init_qubit2stat;

    // construction

    CPUImplQPU();
    CPUImplQPU(size_t);

    // methods

    QGateParam& findgroup(size_t qn);

    bool TensorProduct(
        QGateParam& qgroup0,
        QGateParam& qgroup1
        );

    template <
        const qcomplex_t& U00,
        const qcomplex_t& U01,
        const qcomplex_t& U10,
        const qcomplex_t& U11
        >
    QError single_gate(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    QError U1_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    template <const double& Nx, const double& Ny, const double& Nz>
    QError single_angle_gate(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    template <const double& Nx, const double& Ny, const double& Nz>
    QError control_single_angle_gate(
        size_t qn,
        double theta,
        Qnum vControlBit,
        bool isConjugate,
        double error_rate
        );

    template <
        const qcomplex_t& U00,
        const qcomplex_t& U01,
        const qcomplex_t& U10,
        const qcomplex_t& U11
        >
    QError control_single_gate(
        size_t qn,
        Qnum vControlBit,
        bool isConjugate,
        double error_rate
        );

    CONST_GATE(P0);
    CONST_GATE(P1);
    CONST_GATE(X);
    CONST_GATE(Y);
    CONST_GATE(Z);
    CONST_GATE(Hadamard);
    CONST_GATE(T);
    CONST_GATE(S);
    SINGLE_ANGLE_GATE(RX_GATE);
    SINGLE_ANGLE_GATE(RY_GATE);
    SINGLE_ANGLE_GATE(RZ_GATE);
    CONTROL_SINGLE_ANGLE_GATE(RX_GATE);
    CONTROL_SINGLE_ANGLE_GATE(RY_GATE);
    CONTROL_SINGLE_ANGLE_GATE(RZ_GATE);
    CONTROL_CONST_GATE(Hadamard);
    CONTROL_CONST_GATE(X);
    CONTROL_CONST_GATE(Y);
    CONTROL_CONST_GATE(Z);
    CONTROL_CONST_GATE(T);
    CONTROL_CONST_GATE(S);
    CONTROL_CONST_GATE(P0);
    CONTROL_CONST_GATE(P1);

    QError CNOT(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    QError CNOT(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        double theta,
        bool isConjugate,
        double
        );

    QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double
        );

    QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    QError SqiSWAP(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    QError SqiSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    QError CR(
        size_t qn_0,
        size_t qn_1,
        double theta,
        bool isConjugate,
        double error_rate
        );

    QError CR(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double error_rate
        );

    QError CZ(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    QError CZ(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType);
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType);
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);

    QError DiagonalGate(
        Qnum& vQubit,
        QStat& matrix,
        bool isConjugate,
        double error_rate
        );

    QError controlDiagonalGate(
        Qnum& vQubit,
        QStat& matrix,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QStat getQState();
    virtual QError Reset(size_t qn);
    virtual bool qubitMeasure(size_t qn);

    QError pMeasure(
        Qnum& qnum,
        prob_tuple& mResult,
        int select_max = -1
        );

    virtual QError pMeasure(
        Qnum& qnum,
        prob_vec& mResult
        );

    virtual QError initState(
        size_t head_rank,
        size_t rank_size,
        size_t qubit_num
        );

    virtual QError initState(
        size_t qubit_num,
        const QStat& state = {}
        );

    QError P00(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    QError SWAP(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    QError P11(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );
};

// direct descendants

class CPUImplQPUWithOracle;

Inherited Members

public:
    // methods

    virtual bool qubitMeasure(size_t qn) = 0;
    virtual QError pMeasure(Qnum& qnum, prob_vec& mResult) = 0;
    virtual QError initState(size_t head_rank, size_t rank_size, size_t qubit_num) = 0;
    virtual QError initState(size_t qubit_num, const QStat& state = {}) = 0;
    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QStat getQState() = 0;
    virtual void set_random_engine(RandomEngine* rng);
    virtual double get_random_double();
    virtual QError Reset(size_t qn) = 0;

Detailed Documentation

QPU implementation by CPU model.

Methods

virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType)

unitary single qubit gate

Parameters:

size_t	qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitarySingleQubitGate(
    size_t qn,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

controlunitary single qubit gate

Parameters:

size_t	qubit address
Qnum&	control qubit addresses
QStat	& matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError unitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

unitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

controlunitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
Qnum&	control qubit addresses
QStat&	quantum states
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QStat getQState()

get quantum states

virtual QError Reset(size_t qn)

reset qubit

Parameters:

size_t

qubit address

class DefaultRandomEngine

Default Random Engine.

#include <RandomEngine.h>

class DefaultRandomEngine: public RandomEngine
{
public:
    // construction

    DefaultRandomEngine();
    DefaultRandomEngine(long long seed);

    // methods

    virtual double operator () ();
};

Inherited Members

public:
    // methods

    virtual double operator () () = 0;
    virtual std::vector<double> operator () (size_t n);

class DistributedFullAmplitudeEngine

Overview

Distributed full amplitude engine. More…

#include <AbstractFullAmplitudeEngine.h>

class DistributedFullAmplitudeEngine: public QPUImpl
{
public:
    // methods

    virtual bool qubitMeasure(size_t qn);

    virtual QError pMeasure(
        Qnum& qnum,
        prob_vec& mResult
        );

    virtual QError initState(
        size_t head_rank,
        size_t rank_size,
        size_t qubit_num
        );

    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType);
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType);
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    virtual QStat getQState();
    virtual QError Reset(size_t qn);
};

Inherited Members

public:
    // methods

    virtual bool qubitMeasure(size_t qn) = 0;
    virtual QError pMeasure(Qnum& qnum, prob_vec& mResult) = 0;
    virtual QError initState(size_t head_rank, size_t rank_size, size_t qubit_num) = 0;
    virtual QError initState(size_t qubit_num, const QStat& state = {}) = 0;
    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QStat getQState() = 0;
    virtual void set_random_engine(RandomEngine* rng);
    virtual double get_random_double();
    virtual QError Reset(size_t qn) = 0;

Detailed Documentation

Distributed full amplitude engine.

Methods

virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType)

unitary single qubit gate

Parameters:

size_t	qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitarySingleQubitGate(
    size_t qn,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

controlunitary single qubit gate

Parameters:

size_t	qubit address
Qnum&	control qubit addresses
QStat	& matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError unitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

unitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

controlunitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
Qnum&	control qubit addresses
QStat&	quantum states
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QStat getQState()

get quantum states

virtual QError Reset(size_t qn)

reset qubit

Parameters:

size_t

qubit address

class DoubleGateNoiseModeMap

Double gate noise mode map.

#include <NoiseModel.h>

class DoubleGateNoiseModeMap
{
public:
    // methods

    static DoubleGateNoiseModeMap& getInstance();
    noise_mode_function operator [] (NOISE_MODEL);
};

class QPanda::MPSImplQPU

Overview

QPU implementation by MPS model. More…

#include <MPSImplQPU.h>

class MPSImplQPU: public QPUImpl
{
public:
    // fields

    std::vector<MPS_Tensor> m_qubits_tensor;
    std::vector<rvector_t> m_lambdas;

    // methods

    size_t get_qubit_num();
    virtual bool qubitMeasure(size_t qn);

    virtual QError pMeasure(
        Qnum& qnum,
        prob_vec& mResult
        );

    virtual QError initState(
        size_t head_rank,
        size_t rank_size,
        size_t qubit_num
        );

    void initState(const MPSImplQPU& other);

    virtual QError initState(
        size_t qubit_num,
        const QStat& state = {}
        );

    void initState_from_matrix(size_t num_qubits, const cmatrix_t& mat);
    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType);
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType);
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    virtual QStat getQState();
    virtual QError Reset(size_t qn);
    size_t get_qubit_index(size_t index) const;
    void change_qubits_location(size_t src, size_t dst);
    void swap_qubits_location(size_t index_A, size_t index_B);
    bool measure_one_collapsing(size_t qubit);
    std::vector<std::vector<size_t>> measure_all_noncollapsing(Qnum measure_qubits, int shots);
    cmatrix_t mul_v_by_s(const cmatrix_t& mat, const rvector_t& lambda);
    MPS_Tensor convert_qstate_to_mps_form(size_t first_index, size_t last_index);
    void centralize_and_sort_qubits(const Qnum& qubits, Qnum& sorted_indices, Qnum& centralized_qubits);
    void move_all_qubits_to_sorted_ordering();
    void move_qubits_to_right_end(const Qnum& qubits, Qnum& target_qubits, Qnum& actual_indices);
    void execute_one_qubit_gate(size_t qn, const cmatrix_t& mat);
    void execute_two_qubit_gate(size_t qn_0, size_t qn_1, const cmatrix_t& mat);
    void execute_multi_qubit_gate(const Qnum& qubits, const cmatrix_t& mat);
    qcomplex_t expectation_value_pauli(const Qnum& qubits);

    qcomplex_t expectation_value_pauli_internal(
        const Qnum& qubits,
        const std::vector<GateType>& matrices,
        size_t first_index,
        size_t last_index,
        size_t num_Is
        );

    bool apply_measure(size_t qubit);
    Qnum apply_measure(Qnum qubits);
    cmatrix_t density_matrix(const Qnum& qubits);

    double expectation_value(
        const Qnum& qubits,
        const cmatrix_t& matrix
        );

    double single_expectation_value(
        const Qnum& qubits,
        const cmatrix_t& matrix
        );

    double double_expectation_value(
        const Qnum& qubits,
        const cmatrix_t& matrix
        );

    void unitaryQubitGate(
        Qnum qubits,
        QStat matrix,
        bool isConjugate
        );

    qcomplex_t pmeasure_bin_index(std::string str);
    qcomplex_t pmeasure_dec_index(std::string str);
    QStat pmeasure_bin_subset(const std::vector<std::string>& bin_strs);
    QStat pmeasure_dec_subset(const std::vector<std::string>& dec_strs);
};

Inherited Members

public:
    // methods

    virtual bool qubitMeasure(size_t qn) = 0;
    virtual QError pMeasure(Qnum& qnum, prob_vec& mResult) = 0;
    virtual QError initState(size_t head_rank, size_t rank_size, size_t qubit_num) = 0;
    virtual QError initState(size_t qubit_num, const QStat& state = {}) = 0;
    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QStat getQState() = 0;
    virtual void set_random_engine(RandomEngine* rng);
    virtual double get_random_double();
    virtual QError Reset(size_t qn) = 0;

Detailed Documentation

QPU implementation by MPS model.

Fields

std::vector<MPS_Tensor> m_qubits_tensor

the tensor of qubits.

std::vector<rvector_t> m_lambdas

lambdas between tensors.

Methods

void initState_from_matrix(size_t num_qubits, const cmatrix_t& mat)

init state from matrix

Parameters:

size_t	number of qubits
cmatrix_t	matrix

virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType)

unitary single qubit gate

Parameters:

size_t	qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitarySingleQubitGate(
    size_t qn,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

controlunitary single qubit gate

Parameters:

size_t	qubit address
Qnum&	control qubit addresses
QStat	& matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError unitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

unitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

controlunitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
Qnum&	control qubit addresses
QStat&	quantum states
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QStat getQState()

get quantum states

Returns:

QStat quantum states

virtual QError Reset(size_t qn)

reset qubit

Parameters:

size_t

qubit address

size_t get_qubit_index(size_t index) const

gets the position of the qubits in MPS form

Parameters:

size_t

qubits index

Returns:

size_t the position on m_qubits_location

void change_qubits_location(size_t src, size_t dst)

change two qubits

Parameters:

size_t	src qubit location
size_t	dst qubit location

void swap_qubits_location(size_t index_A, size_t index_B)

execute SWAP gate, the state of swapping two qubits

Parameters:

size_t	A qubit index
size_t	B qubit index

bool measure_one_collapsing(size_t qubit)

measure one qubit collapsing

Parameters:

size_t

the qubit position of the measurement

Returns:

bool the measurement results

std::vector<std::vector<size_t>> measure_all_noncollapsing(
    Qnum measure_qubits,
    int shots
    )

measure all qubits collapsing

Parameters:

size_t

the qubit position of the measurement

Returns:

std::vector<std::vector<size_t>> the measurement results

cmatrix_t mul_v_by_s(const cmatrix_t& mat, const rvector_t& lambda)

after the SVD decomposition , The product of S and V

Parameters:

cmatrix_t	V matrix
rvector_t	S vector

Returns:

cmatrix_t product

MPS_Tensor convert_qstate_to_mps_form(size_t first_index, size_t last_index)

convert to MPS form

Parameters:

size_t	starting position
size_t	end position

Returns:

MPS_Tensor MPS form tensor

void centralize_and_sort_qubits(
    const Qnum& qubits,
    Qnum& sorted_indices,
    Qnum& centralized_qubits
    )

sort qubits location, and centralize qubits locations

Parameters:

Qnum	original qubits location
Qnum	sorted indices
Qnum	centralized qubits location

void move_all_qubits_to_sorted_ordering()

move all qubits to sorted ordering

void move_qubits_to_right_end(const Qnum& qubits, Qnum& target_qubits, Qnum& actual_indices)

move qubits to right_end location

Parameters:

Qnum	original qubits location
Qnum	target qubits location
actual	indices

void execute_one_qubit_gate(size_t qn, const cmatrix_t& mat)

execute one qubit gate

Parameters:

size_t	target qubit
cmatrix_t	gate matrix

void execute_two_qubit_gate(size_t qn_0, size_t qn_1, const cmatrix_t& mat)

execute two qubits gate

Parameters:

size_t	control qubit
size_t	target qubit
cmatrix_t	gate matrix

void execute_multi_qubit_gate(const Qnum& qubits, const cmatrix_t& mat)

execute multi qubits gate

Parameters:

size_t	control and target qubits, target qubit in the tail
cmatrix_t	gate matrix

class QPanda::MPSQVM

Overview

MPS quantum virtual machine. More…

#include <MPSQVM.h>

class MPSQVM:
    public QPanda::IdealQVM,
    private QPanda::TraversalInterface
{
public:
    // methods

    virtual void init();

    virtual void initState(
        const QStat& state = {},
        const QVec& qlist = {}
        );

    virtual std::map<std::string, bool> directlyRun(QProg& qProg);

    virtual std::map<std::string, size_t> quickMeasure(
        QVec vQubit,
        size_t shots
        );

    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual QStat getQState();

    virtual prob_tuple pMeasure(
        QVec qubits,
        int select_max = -1
        );

    virtual prob_tuple PMeasure(
        QVec qubits,
        int select_max = -1
        );

    virtual prob_vec PMeasure_no_index(QVec qubits);
    prob_vec pMeasureNoIndex(QVec qubit_vector);

    qcomplex_t pmeasure_bin_index(
        QProg prog,
        std::string str
        );

    qcomplex_t pmeasure_dec_index(
        QProg prog,
        std::string str
        );

    QStat pmeasure_bin_subset(
        QProg prog,
        const std::vector<std::string>& bin_strs
        );

    QStat pmeasure_dec_subset(
        QProg prog,
        const std::vector<std::string>& dec_strs
        );

    virtual prob_tuple getProbTupleList(
        QVec,
        int selectMax = -1
        );

    virtual prob_vec getProbList(
        QVec,
        int selectMax = -1
        );

    virtual prob_dict getProbDict(
        QVec,
        int selectMax = -1
        );

    virtual prob_tuple probRunTupleList(
        QProg&,
        QVec,
        int selectMax = -1
        );

    virtual prob_vec probRunList(
        QProg&,
        QVec,
        int selectMax = -1
        );

    virtual prob_dict probRunDict(
        QProg&,
        QVec,
        int selectMax = -1
        );

    void execute(
        std::shared_ptr<AbstractQGateNode>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractClassicalProg>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumMeasure>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumReset>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumCircuit>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumProgram>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractControlFlowNode>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>&
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>&,
        const std::vector<double>&
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>&,
        const std::vector<QVec>&
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>&,
        const std::vector<double>&,
        const std::vector<QVec>&
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double param
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double param,
        const QVec& qubits_vec
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double param,
        const std::vector<QVec>& qubits_vecs
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double T1,
        double T2,
        double time_param
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double T1,
        double T2,
        double time_param,
        const QVec& qubits_vec
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double T1,
        double T2,
        double time_param,
        const std::vector<QVec>& qubits_vecs
        );

    void set_readout_error(
        const std::vector<std::vector<double>>& readout_params,
        const QVec& qubits
        );

    void set_measure_error(
        NOISE_MODEL model,
        double param
        );

    void set_measure_error(
        NOISE_MODEL model,
        double param,
        const QVec& qubits_vec
        );

    void set_measure_error(
        NOISE_MODEL model,
        double T1,
        double T2,
        double time_param
        );

    void set_measure_error(
        NOISE_MODEL model,
        double T1,
        double T2,
        double time_param,
        const QVec& qubits_vec
        );

    void set_rotation_error(double param);

    void set_reset_error(
        double reset_0_param,
        double reset_1_param
        );
};

Inherited Members

public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {}) = 0;
    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {});
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t);
    virtual QMachineStatus* getStatus() const;
    virtual QResult* getResult();
    virtual std::map<std::string, bool> getResultMap();
    virtual void finalize();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<int>&, int);
    virtual std::map<GateType, size_t> getGateTimeMap() const;
    virtual QStat getQState() const;
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*);
    virtual void set_random_engine(RandomEngine* rng);
    virtual void setConfig(const Configuration& config);
    virtual Qubit* allocateQubit();
    virtual QVec allocateQubits(size_t);
    virtual ClassicalCondition allocateCBit();
    virtual std::vector<ClassicalCondition> allocateCBits(size_t);
    virtual ClassicalCondition allocateCBit(size_t);
    virtual size_t getAllocateQubit();
    virtual size_t getAllocateCMem();
    virtual void Free_Qubit(Qubit*);
    virtual void Free_Qubits(QVec&);
    virtual void Free_CBit(ClassicalCondition&);
    virtual void Free_CBits(std::vector<ClassicalCondition>&);
    virtual void setConfigure(const Configuration&);
    virtual Qubit* qAlloc();
    virtual QVec qAllocMany(size_t qubit_count);
    virtual ClassicalCondition cAlloc();
    virtual ClassicalCondition cAlloc(size_t);
    virtual std::vector<ClassicalCondition> cAllocMany(size_t);
    virtual void qFree(Qubit*);
    virtual void qFreeAll(QVec&);
    virtual void cFree(ClassicalCondition&);
    virtual void cFreeAll(std::vector<ClassicalCondition>&);
    virtual size_t getAllocateQubitNum();
    virtual size_t getAllocateCMemNum();
    virtual size_t get_allocate_qubits(QVec&);
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int);
    virtual prob_vec PMeasure_no_index(QVec qubit_vector) = 0;
    virtual prob_tuple getProbTupleList(QVec, int) = 0;
    virtual prob_vec getProbList(QVec, int) = 0;
    virtual prob_dict getProbDict(QVec, int) = 0;
    virtual prob_tuple probRunTupleList(QProg&, QVec, int) = 0;
    virtual prob_vec probRunList(QProg&, QVec, int) = 0;
    virtual prob_dict probRunDict(QProg&, QVec, int) = 0;
    virtual std::map<std::string, size_t> quickMeasure(QVec, size_t) = 0;
    virtual prob_tuple PMeasure(QVec qubit_vector, int select_max) = 0;
    virtual QStat getQStat() = 0;
    virtual prob_tuple getProbTupleList(QVec, int selectMax = -1);
    virtual prob_vec getProbList(QVec, int selectMax = -1);
    virtual prob_dict getProbDict(QVec, int selectMax = -1);
    virtual prob_tuple probRunTupleList(QProg&, QVec, int selectMax = -1);
    virtual prob_vec probRunList(QProg&, QVec, int selectMax = -1);
    virtual prob_dict probRunDict(QProg&, QVec, int selectMax = -1);
    prob_tuple probRunTupleList(QProg&, const std::vector<int>&, int selectMax = -1);
    prob_vec probRunList(QProg&, const std::vector<int>&, int selectMax = -1);
    prob_dict probRunDict(QProg&, const std::vector<int>&, int selectMax = -1);
    virtual std::map<std::string, size_t> quickMeasure(QVec, size_t);
    virtual QStat getQStat();
    virtual prob_tuple PMeasure(QVec qubit_vector, int select_max);
    virtual prob_vec PMeasure_no_index(QVec qubit_vector);
    QStat getQState();
    prob_tuple pMeasure(QVec qubit_vector, int select_max);
    prob_vec pMeasureNoIndex(QVec qubit_vector);

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

MPS quantum virtual machine.

Methods

virtual void init()

init

Returns:

void

virtual std::map<std::string, bool> directlyRun(QProg& qProg)

directlyRun

Parameters:

QProg&

quantum program

Returns:

std::map<std::string, bool>

virtual std::map<std::string, size_t> runWithConfiguration(
    QProg&,
    std::vector<ClassicalCondition>&,
    int
    )

runWithConfiguration

Parameters:

QProg&	quantum program
std::vector<ClassicalCondition>&
int

Returns:

std::map<std::string, Eigen::size_t>

virtual std::map<std::string, size_t> runWithConfiguration(
    QProg&,
    std::vector<ClassicalCondition>&,
    rapidjson::Document&
    )

runWithConfiguration

Parameters:

QProg&	quantum program
std::vector<ClassicalCondition>&
rapidjson::Document&

Returns:

std::map<std::string, Eigen::size_t>

class NoisyCPUImplQPU

Overview

QPU implementation by noisy CPU model. More…

#include <NoiseCPUImplQPU.h>

class NoisyCPUImplQPU: public QPUImpl
{
public:
    // fields

    vQParam qubit2stat;
    vQParam init_qubit2stat;

    // construction

    NoisyCPUImplQPU();
    NoisyCPUImplQPU(rapidjson::Document&);
    NoisyCPUImplQPU(NoisyQuantum& quantum_noise);

    // methods

    QGateParam& findgroup(size_t qn);
    void set_quantum_noise(const NoisyQuantum& quantum_noise);

    bool TensorProduct(
        QGateParam& qgroup0,
        QGateParam& qgroup1
        );

    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType);

    QError noisyUnitarySingleQubitGate(
        size_t qn,
        QStat& matrix,
        bool isConjugate,
        NoiseOp& noise
        );

    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType);

    QError noisyUnitaryDoubleQubitGate(
        size_t qn_0,
        size_t qn_1,
        QStat& matrix,
        bool isConjugate,
        NoiseOp& noise
        );

    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);

    virtual QError Hadamard(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError Hadamard(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError X(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError X(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError P0(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError P0(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError P1(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError P1(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError Y(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError Y(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError Z(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError Z(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError T(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError T(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError S(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError S(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError U1_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError RX_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError RX_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError RY_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError RY_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError RZ_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError RZ_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError CNOT(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    virtual QError CNOT(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError CR(
        size_t qn_0,
        size_t qn_1,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError CR(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError CZ(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    virtual QError CZ(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError SqiSWAP(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    virtual QError SqiSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError DiagonalGate(
        Qnum& vQubit,
        QStat& matrix,
        bool isConjugate,
        double error_rate
        );

    virtual QError controlDiagonalGate(
        Qnum& vQubit,
        QStat& matrix,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QStat getQState();
    virtual QError Reset(size_t qn);
    virtual bool qubitMeasure(size_t qn);

    QError pMeasure(
        Qnum& qnum,
        prob_tuple& mResult,
        int select_max = -1
        );

    virtual QError pMeasure(
        Qnum& qnum,
        prob_vec& mResult
        );

    virtual QError initState(
        size_t head_rank,
        size_t rank_size,
        size_t qubit_num
        );

    virtual QError initState(
        size_t qubit_num,
        const QStat& state = {}
        );

    QError unitary_noise_qubit_gate(
        const Qnum& qns,
        const QStat& matrix,
        bool is_conjugate,
        GateType type
        );

    QError unitary_noise_qubit_kraus(
        const Qnum& qns,
        const NoiseOp& ops,
        QStat& standard_matrix
        );

    QError unitary_qubit_gate_standard(
        size_t qn,
        QStat& matrix,
        bool is_conjugate
        );

    QError unitary_qubit_gate_standard(
        size_t qn0,
        size_t qn1,
        QStat& matrix,
        bool is_conjugate
        );

    QError reset_standard(size_t qn);
    bool measure_standard(size_t qn);

    bool readout(
        bool measure,
        size_t qn
        );

    void normlize(
        QStat& matrix,
        double p
        );

    double unitary_kraus(
        const Qnum& qns,
        const QStat& op
        );
};

Inherited Members

public:
    // methods

    virtual bool qubitMeasure(size_t qn) = 0;
    virtual QError pMeasure(Qnum& qnum, prob_vec& mResult) = 0;
    virtual QError initState(size_t head_rank, size_t rank_size, size_t qubit_num) = 0;
    virtual QError initState(size_t qubit_num, const QStat& state = {}) = 0;
    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QStat getQState() = 0;
    virtual void set_random_engine(RandomEngine* rng);
    virtual double get_random_double();
    virtual QError Reset(size_t qn) = 0;

Detailed Documentation

QPU implementation by noisy CPU model.

Methods

virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType)

unitary single qubit gate

Parameters:

size_t	qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitarySingleQubitGate(
    size_t qn,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

controlunitary single qubit gate

Parameters:

size_t	qubit address
Qnum&	control qubit addresses
QStat	& matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError unitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

unitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

controlunitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
Qnum&	control qubit addresses
QStat&	quantum states
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QStat getQState()

get quantum states

virtual QError Reset(size_t qn)

reset qubit

Parameters:

size_t

qubit address

class QPanda::PartialAmplitudeGraph

Partial Amplitude Graph.

#include <PartialAmplitudeGraph.h>

class PartialAmplitudeGraph
{
public:
    // fields

    uint32_t m_spilt_num;
    uint32_t m_qubit_num;
    std::vector<QGateNode> m_circuit;
    std::vector<std::vector<cir_type>> m_sub_graph;

    // methods

    void reset(size_t qubit_num);

    void computing_graph(
        const cir_type&,
        QPUImpl*
        );

    bool is_corss_node(
        size_t,
        size_t
        );

    void traversal(std::vector<QGateNode>&);
    void split_circuit(std::vector<QGateNode>&);
};

class QPUImpl

Overview

QPU implementation base class. More…

#include <QPUImpl.h>

class QPUImpl
{
public:
    // methods

    virtual bool qubitMeasure(size_t qn) = 0;

    virtual QError pMeasure(
        Qnum& qnum,
        prob_vec& mResult
        ) = 0;

    virtual QError initState(
        size_t head_rank,
        size_t rank_size,
        size_t qubit_num
        ) = 0;

    virtual QError initState(
        size_t qubit_num,
        const QStat& state = {}
        ) = 0;

    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QStat getQState() = 0;
    virtual void set_random_engine(RandomEngine* rng);
    virtual double get_random_double();
    virtual QError Reset(size_t qn) = 0;
};

// direct descendants

class CPUImplQPU;
class CPUImplQPUSingleThread;
class DistributedFullAmplitudeEngine;
class NoisyCPUImplQPU;
class MPSImplQPU;

Detailed Documentation

QPU implementation base class.

Methods

virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType) = 0

unitary single qubit gate

Parameters:

size_t	qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitarySingleQubitGate(
    size_t qn,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    ) = 0

controlunitary single qubit gate

Parameters:

size_t	qubit address
Qnum&	control qubit addresses
QStat	& matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError unitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    QStat& matrix,
    bool isConjugate,
    GateType
    ) = 0

unitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    ) = 0

controlunitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
Qnum&	control qubit addresses
QStat&	quantum states
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QStat getQState() = 0

get quantum states

virtual QError Reset(size_t qn) = 0

reset qubit

Parameters:

size_t

qubit address

class RandomEngine

Random Engine.

#include <RandomEngine.h>

class RandomEngine
{
public:
    // methods

    virtual double operator () () = 0;
    virtual std::vector<double> operator () (size_t n);
};

// direct descendants

class DefaultRandomEngine;
class XC_RandomEngine16807;

class SingleGateNoiseModeMap

Single gate noise mode map.

#include <NoiseModel.h>

class SingleGateNoiseModeMap
{
public:
    // methods

    static SingleGateNoiseModeMap& getInstance();
    noise_mode_function operator [] (NOISE_MODEL);
};

class XC_RandomEngine16807

XC Random Engine.

#include <RandomEngine.h>

class XC_RandomEngine16807: public RandomEngine
{
public:
    // construction

    XC_RandomEngine16807();
    XC_RandomEngine16807(long long _seed);

    // methods

    virtual double operator () ();
};

Inherited Members

public:
    // methods

    virtual double operator () () = 0;
    virtual std::vector<double> operator () (size_t n);

Overview

QPanda2 virtual quantum processor. More…

// classes

class AbstractDistributedFullAmplitudeEngine;
class AbstractQuantumGates;
class CPUImplQPU;
class DefaultRandomEngine;
class DistributedFullAmplitudeEngine;
class DoubleGateNoiseModeMap;
class QPanda::MPSImplQPU;
class QPanda::MPSQVM;
class NoisyCPUImplQPU;
class QPanda::PartialAmplitudeGraph;
class QPUImpl;
class RandomEngine;
class SingleGateNoiseModeMap;
class XC_RandomEngine16807;

// global functions

bool bit_phase_flip_operator (rapidjson::Value& value, NoiseOp& noise);
bool phase_damping_oprator(rapidjson::Value& value, NoiseOp& noise);
bool double_bit_phase_flip_operator (rapidjson::Value& value, NoiseOp& noise);
bool double_phase_damping_oprator(rapidjson::Value& value, NoiseOp& noise);

Detailed Documentation

QPanda2 virtual quantum processor.

Global Functions

bool bit_phase_flip_operator (rapidjson::Value& value, NoiseOp& noise)

Get Noise model bit-phase flip matrix.

Use this at the SingleGateNoiseModeMap constructor

Parameters:

rapidjson::Value	Noise model and probability
NoiseOp	Noise model matrix: E1 = sqrt(1-p){1,0,0,1}, E2 = sqrt(p) {0,-i,i,0}

Returns:

bool true:get matrix success, false:get matrix failed

bool phase_damping_oprator(rapidjson::Value& value, NoiseOp& noise)

Get Noise model bit-phase flip matrix.

Use this at the SingleGateNoiseModeMap constructor

Parameters:

rapidjson::Value	Noise model and probability
NoiseOp	Noise model matrix: E1 = {1,0,0,sqrt(1-p)} , E2 = {0,0,0,sqrt(p)}

Returns:

bool true:get matrix success, false:get matrix failed

bool double_bit_phase_flip_operator (rapidjson::Value& value, NoiseOp& noise)

Get Noise model bit-phase flip matrix.

Use this at the DoubleGateNoiseModeMap constructor

Parameters:

rapidjson::Value	Noise model and probability
NoiseOp	Noise model matrix: E1 = sqrt(1-p){1,0,0,1}, E2 = sqrt(p) {0,-i,i,0}

Returns:

bool true:get matrix success, false:get matrix failed

bool double_phase_damping_oprator(rapidjson::Value& value, NoiseOp& noise)

Get Noise model bit-phase flip matrix.

Use this at the DoubleGateNoiseModeMap constructor

Parameters:

rapidjson::Value	Noise model and probability
NoiseOp	Noise model matrix: E1 = {1,0,0,sqrt(1-p)}, E2 = {0,0,0,sqrt(p)}

Returns:

bool true:get matrix success, false:get matrix failed

Overview

QPanda2 Core Group. More…

QuantumCircuit

QuantumMachine

Utilities

Variational

VirtualQuantumProcessor

// global functions

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

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

QStat QPanda::getQState();
QuantumMachine* QPanda::initQuantumMachine(QMachineType type = CPU);
void QPanda::destroyQuantumMachine(QuantumMachine* qvm);
QPanda::QProg QPanda::MeasureAll(QVec, std::vector<ClassicalCondition>);
size_t QPanda::getAllocateCMemNum();
prob_tuple QPanda::pMeasure(QVec qubit_vector, int select_max);
prob_vec QPanda::pMeasureNoIndex(QVec qubit_vector);
QMeasure QPanda::Measure(Qubit*, ClassicalCondition);
QMeasure QPanda::Measure(int, int);

Detailed Documentation

QPanda2 Core Group.

Global Functions

bool QPanda::init(QMachineType type = CPU)

Init the environment.

Use this at the beginning

Parameters:

QMachineType

Quantum machine type

Returns:

bool

See also:

QMachineType

void QPanda::finalize()

Finalize the environment.

Use this at the end

Returns:

void

Qubit* QPanda::qAlloc()

Allocate a qubit.

Call init() before you use this

Returns:

void

Qubit* QPanda::qAlloc(size_t stQubitAddr)

Allocate a qubit.

Call init() before you use this

Parameters:

size_t

set qubit address

Returns:

void

std::map<std::string, bool> QPanda::directlyRun(QProg& qProg)

Directly run a quantum program.

Parameters:

QProg&

Quantum program

Returns:

std::map<std::string, bool> result

QVec QPanda::qAllocMany(size_t stQubitNumber)

Allocate many qubits.

Call init() before you use this

Parameters:

size_t

set qubit number

ClassicalCondition QPanda::cAlloc()

Allocate a cbit.

Call init() before you use this

Returns:

ClassicalCondition cbit

ClassicalCondition QPanda::cAlloc(size_t stCBitaddr)

Allocate a cbit.

Call init() before you use this

Parameters:

size_t

set cbit address

Returns:

ClassicalCondition Cbit

std::vector<ClassicalCondition> QPanda::cAllocMany(size_t stCBitNumber)

Allocate many cbits.

Call init() before you use this

Parameters:

size_t

set cbit number

void QPanda::cFree(ClassicalCondition&)

Free a cbit.

Parameters:

ClassicalCondition&

a reference to a cbit

Returns:

void

void QPanda::cFreeAll(std::vector<ClassicalCondition> vCBit)

Free a list of cbits.

Parameters:

std::vector<ClassicalCondition>

a list of cbits

Returns:

void

QMachineStatus* QPanda::getstat()

Get the status(ptr) of the Quantum machine.

Returns:

QPanda::QMachineStatus * Quantum machine status(ptr)

size_t QPanda::getAllocateQubitNum()

Get all allocate qubit num.

Returns:

size_t Qubit num

prob_tuple QPanda::getProbTupleList(QVec, int selectMax = -1)

Get pmeasure result as tuple list.

selectMax can not exceed (1ull << the size of qubits vector)

Parameters:

QVec	pmeasure qubits vector
int	Selectmax:the returned value num

Returns:

std::vector<std::pair<size_t, double>> result

prob_vec QPanda::getProbList(QVec, int selectMax = -1)

Get pmeasure result as list.

SelectMax can not exceed (1ull << the size of qubits vector)

Parameters:

QVec	pmeasure qubits vector
int	Selectmax:the returned value num

Returns:

prob_vec result

prob_dict QPanda::getProbDict(QVec, int selectMax = -1)

Get pmeasure result as dict.

SelectMax can not exceed (1ull << the size of qubits vector)

Parameters:

QVec	pmeasure qubits vector
int	Selectmax:the returned value num

Returns:

std::map<std::string, double> result

prob_tuple QPanda::probRunTupleList(QProg&, QVec, int selectMax = -1)

Get pmeasure result as dict.

SelectMax can not exceed (1ull << the size of qubits vector)

Parameters:

QProg&	Quantum program
QVec	pmeasure qubits vector
int	Selectmax:the returned value num

Returns:

std::vector<std::pair<size_t, double>> result

prob_vec QPanda::probRunList(QProg&, QVec, int selectMax = -1)

Get pmeasure result as list.

SelectMax can not exceed (1ull << the size of qubits vector)

Parameters:

QProg&	Quantum program
QVec	Pmeasure qubits vector
int	selectmax:the returned value num

Returns:

prob_vec result

prob_dict QPanda::probRunDict(QProg&, QVec, int selectMax = -1)

Get pmeasure result as dict.

SelectMax can not exceed (1ull << the size of qubits vector)

Parameters:

QProg&	Quantum program
QVec	pmeasure qubits vector
int	Selectmax:the returned value num

Returns:

std::map<std::string, double> result

std::map<std::string, size_t> QPanda::runWithConfiguration(
    QProg&,
    std::vector<ClassicalCondition>&,
    int
    )

Measure run with configuration.

Parameters:

QProg&	Quantum program
std::vector<ClassicalCondition>&	cbits vector
int	Shots:the repeat num of measure operate

Returns:

std::map<std::string, size_t> result

std::map<std::string, size_t> QPanda::quickMeasure(QVec, int)

Quick measure operate.

Parameters:

QVec	qubits vector
int	Shots:the repeat num of measure operate

Returns:

std::map<std::string,size_t> result

prob_vec QPanda::accumulateProbability(prob_vec& prob_list)

AccumulateProbability.

Parameters:

prob_vec

& prob_list Abstract Quantum program pointer

Returns:

prob_vec

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

Quick measure.

Parameters:

QVec	qubits vector
int	Shots:the repeat num of measure operate
prob_vec&	accumulate Probabilites

Returns:

std::map<std::string,size_t> Results

QStat QPanda::getQState()

Get quantum state.

Returns:

qstat Quantum state vector

QuantumMachine* QPanda::initQuantumMachine(QMachineType type = CPU)

Init a Quantum machine.

default Quantum machine type :cpu

Parameters:

QMachineType

Returns:

QPanda::QuantumMachine * Quantum machine pointer

See also:

QMachineType

void QPanda::destroyQuantumMachine(QuantumMachine* qvm)

Destroy Quantum machine.

Parameters:

QuantumMachine*

Quantum machine pointer

Returns:

void

QPanda::QProg QPanda::MeasureAll(QVec, std::vector<ClassicalCondition>)

Measure All ClassicalCondition.

Parameters:

QVec&	qubits vector
std::vector<ClassicalCondition>	Cbits vector

Returns:

QPanda::QProg Quantum program

size_t QPanda::getAllocateCMemNum()

Get allocate cbit number.

Returns:

size_t Cbit number

prob_tuple QPanda::pMeasure(QVec qubit_vector, int select_max)

pMeasure

Parameters:

QVec	qubit vector
int	Selectmax:the returned value num

Returns:

std::vector<std::pair<size_t, double>> result

prob_vec QPanda::pMeasureNoIndex(QVec qubit_vector)

pMeasure only return result with no index

Parameters:

QVec	qubit vector

Returns:

prob_vec result

QMeasure QPanda::Measure(Qubit*, ClassicalCondition)

QPanda2 basic interface for creating a quantum measure node.

Parameters:

Qubit*	qubit address
ClassicalCondition	cbit

Returns:

QPanda::QMeasure quantum measure node

QMeasure QPanda::Measure(int, int)

QPanda2 basic interface for creating a quantum measure node.

Parameters:

int	qubit address
int	cbit address

Returns:

QPanda::QMeasure quantum measure node

QAlg

B_V_Algorithm

Bernstein-Vazirani algorithm.

DJ_Algorithm

Deutsch Jozsa algorithm.

Grover_Algorithm

Grover Algorithm.

QAOA

class QPanda::QAOA

Overview

Quantum Approximate Optimization Algorithm. More…

#include <QAOA.h>

class QAOA
{
public:
    // construction

    QAOA(OptimizerType optimizer = OptimizerType::NELDER_MEAD);
    QAOA(const std::string& optimizer);
    QAOA(QAOA&);

    // methods

    QAOA& operator = (QAOA&);
    void setHamiltonian(const PauliOperator& pauli);
    void setDeltaT(double delta_t);
    void setStep(size_t step);
    size_t step();
    void setShots(size_t shots);
    void regiestUserDefinedFunc(const QUserDefinedFunc& func);
    void setDefaultOptimizePara(const vector_d& para);
    void enableLog(bool enabled, std::string filename = "");
    AbstractOptimizer* getOptimizer();
    bool exec();
    QOptimizationResult getOptimizerResult();
    bool scan2Para(const QScanPara& data);
};

Detailed Documentation

Quantum Approximate Optimization Algorithm.

Construction

QAOA(OptimizerType optimizer = OptimizerType::NELDER_MEAD)

Constructor of ChemiQ.

Methods

void setHamiltonian(const PauliOperator& pauli)

set Hamiltonian

Parameters:

QPauliMap&

pauli map

void setDeltaT(double delta_t)

set val of Delta T

Parameters:

double

the val of Delta T

void setStep(size_t step)

set step

Parameters:

size_t

the val of step

size_t step()

get step

Returns:

return the val of step

void setShots(size_t shots)

set Shots val

Parameters:

size_t

the val of Shots

void regiestUserDefinedFunc(const QUserDefinedFunc& func)

regiest user defined functional

Parameters:

QUserDefinedFunc&

the user defined functional

void setDefaultOptimizePara(const vector_d& para)

set default optimize parameter

Parameters:

vector_d&

the default optimize parameters

void enableLog(bool enabled, std::string filename = "")

whether or not enable the log file

Parameters:

bool	whether or not
string	filename log file name

AbstractOptimizer* getOptimizer()

get optimizer object

Returns:

AbstractOptimizer* the optimizer object ptr

bool exec()

execute optimizer

Returns:

return true on success, or else return false

QOptimizationResult getOptimizerResult()

get optimizer result

Returns:

return QOptimizationResult

bool scan2Para(const QScanPara& data)

scan Para to file

Returns:

return true on success, or else return false

QAOA.

// classes

class QPanda::QAOA;

QAlgChemiQ

class QPanda::ChemiQ

Overview

ChemiQ Algorithm class. More…

#include <ChemiQ.h>

class ChemiQ
{
public:
    // methods

    void initialize(const std::string& dir);
    void finalize();
    void setMolecule(const std::string& molecule);
    void setMoleculesStr(const std::string& molecule);
    void setMolecules(const vector_s& molecules);
    void setMultiplicity(int multiplicity);
    void setCharge(int charge);
    void setBasis(const std::string& basis);
    void setEqTolerance(const double val);
    void setTransformType(TransFormType type);
    void setUccType(UccType ucc_type);
    void setOptimizerType(OptimizerType optimizer_type);
    void setOptimizerIterNum(size_t iter_num);
    void setOptimizerFuncCallNum(size_t num);
    void setOptimizerXatol(double value);
    void setOptimizerFatol(double value);
    void setOptimizerDisp(bool enable);
    void setLearningRate(double learning_rate);
    void setEvolutionTime(double t);
    void setHamiltonianSimulationSlices(size_t slices);
    void setSaveDataDir(const std::string dir);
    void setQuantumMachineType(QMachineType type);
    void setRandomPara(bool enable);
    void setDefaultOptimizedPara(const vector_d& para);
    void setToGetHamiltonianFromFile(bool enable);
    void setHamiltonianGenerationOnly(bool enable);
    int getQubitsNum();
    bool exec();
    std::string getLastError() const;
    vector_d getEnergies() const;
};

Detailed Documentation

ChemiQ Algorithm class.

Methods

void initialize(const std::string& dir)

Initialize the quantum chemistry calculation.

Parameters:

std::string

The dir of the psi4 chemistry calculation package

void finalize()

Finalize the quantum chemistry calculation.

void setMolecule(const std::string& molecule)

Set the molecular model to calculate separated by commas(‘

‘) between atoms.

Parameters:

std::string

molecule model

void setMoleculesStr(const std::string& molecule)

Setup molecular models, separated by semicolons(‘;’) and separated by commas(‘,’) between atoms.

Parameters:

std::string

molecule model

void setMolecules(const vector_s& molecules)

Set the molecular model to calculate.

Parameters:

vector_s

molecule model

See also:

vector_s

void setMultiplicity(int multiplicity)

Set the multiplicity of the molecular model.

Parameters:

int	multiplicity

void setCharge(int charge)

Set the charge of the molecular model.

Parameters:

int

charge

void setBasis(const std::string& basis)

Set the calculation basis.

Parameters:

std::string

basis

void setEqTolerance(const double val)

set Eq Tolerance

Parameters:

double

the val of Tolerance

void setTransformType(TransFormType type)

Set the transform type from Fermion operator to Pauli operator.

Parameters:

TransFormType

transform type

See also:

TransFormType

void setUccType(UccType ucc_type)

Set the ucc type to contruct the Fermion operator.

Parameters:

UccType

ucc type

See also:

UccType

void setOptimizerType(OptimizerType optimizer_type)

Set the optimizer type.

Parameters:

OptimizerType

optimizer type

See also:

OptimizerType

void setOptimizerIterNum(size_t iter_num)

Set the optimizer iteration number.

Parameters:

size_t

iteration number

void setOptimizerFuncCallNum(size_t num)

Set the optimizer function callback number.

Parameters:

size_t

function callback number

void setOptimizerXatol(double value)

Set the optimizer xatol.It is the Absolute error in xopt between iterations that is acceptable for convergence.

Parameters:

double

absolute error between iterations

void setOptimizerFatol(double value)

Set the optimizer fatol.It is the Absolute error in func(xopt) between iterations that is acceptable for convergence.

Parameters:

double

absolute error between func(xopt)

void setOptimizerDisp(bool enable)

Whether to print the optimized log to the terminal.

Parameters:

bool

enable

void setLearningRate(double learning_rate)

Set the learing rate when using Gradient optimizer.

Parameters:

double

learing rate

void setEvolutionTime(double t)

Set the evolution time when doing hamiltonian simulation.

Parameters:

double

evolution time

void setHamiltonianSimulationSlices(size_t slices)

Set the hamiltonian simulation slices (e^iAt/n*e^iBt/n)^n, n is the slices.

Parameters:

double

hamiltonian simulation slices

void setSaveDataDir(const std::string dir)

Set the directory to save the calculated data. If it’s a not exist dir data will not be saved.

Parameters:

std::string

dir

void setQuantumMachineType(QMachineType type)

Set the quantum machine type.

Parameters:

QMachineType

quantum machine type

See also:

QMachineType

void setRandomPara(bool enable)

Set random default optimizer paramter.

Parameters:

bool

enable

void setDefaultOptimizedPara(const vector_d& para)

Set the default optimizer paramter by the given paramter.

Parameters:

vecotr_d

default paramter

See also:

vector_d

void setToGetHamiltonianFromFile(bool enable)

Set to get hamiltonian from file.

Parameters:

bool

enable

void setHamiltonianGenerationOnly(bool enable)

Set hamiltonian generation only.

Parameters:

bool

enable

int getQubitsNum()

get qubits num with the above config.

Returns:

int -1:means failed.

bool exec()

exec molecule calculate.

Returns:

bool true:success; false:failed

std::string getLastError() const

get last error.

Returns:

std::string last error

vector_d getEnergies() const

get calculated energies of the molecules.

Returns:

vector_d energies

ChemiQ.

// classes

class QPanda::ChemiQ;

class QPanda::QARM

Quantum Association Rules Mining.

#include <QARMAlgorithm.h>

class QARM
{
public:
    // construction

    QARM(std::vector<std::vector<std::string>> data);

    // methods

    std::map<std::string, double> run();
};

class QPanda::QITE

enum QPanda::QITE::UpdateMode

#include <QITE.h>

enum UpdateMode
{
    GD_VALUE,
    GD_DIRECTION,
};

Overview

Variational Quantum Imagine Time Evolution Algorithem Class. More…

#include <QITE.h>

class QITE
{
public:
    // enums

    enum UpdateMode;

    // methods

    void setHamiltonian(const PauliOperator& h);
    void setAnsatzGate(const std::vector<AnsatzGate>& ansatz_gate);
    void setDeltaTau(double delta_tau);
    void setIterNum(size_t num);
    void setParaUpdateMode(UpdateMode mode);
    void setUpthrowNum(size_t num);
    void setConvergenceFactorQ(double value);
    void setQuantumMachineType(QMachineType type);
    void setLogFile(const std::string& filename);
    void setArbitaryCofficient(double arbitary_cofficient);
    int exec();
    prob_tuple getResult();
};

Detailed Documentation

Variational Quantum Imagine Time Evolution Algorithem Class.

Methods

void setHamiltonian(const PauliOperator& h)

Set problem hamitonian.

Parameters:

const

PauliOperator& problem hamiltoinan

See also:

PauliOperator

void setAnsatzGate(const std::vector<AnsatzGate>& ansatz_gate)

Set ansatz gate.

Parameters:

const

std::vector<AnsatzGate>& ansatz gate vector

See also:

AnsatzGate

void setDeltaTau(double delta_tau)

Set delta tau value.

Parameters:

double

delta tau value

void setIterNum(size_t num)

Set iteration number.

Parameters:

size_t

iteration number

void setParaUpdateMode(UpdateMode mode)

Set parameters update mode.

Parameters:

UpdateMode

parameters update mode

See also:

UpdateMode

void setUpthrowNum(size_t num)

Set upthrow number.

Parameters:

size_t

upthrow number

void setConvergenceFactorQ(double value)

Set convergence factor Q.

Parameters:

size_t

convergence factor Q

void setQuantumMachineType(QMachineType type)

Set the quantum machine type.

Parameters:

QMachineType

quantum machine type

See also:

QMachineType

void setLogFile(const std::string& filename)

Set log file.

Parameters:

const

std::string& log file name

void setArbitaryCofficient(double arbitary_cofficient)

Set arbitary cofficient.

Parameters:

double

arbitary cofficient

int exec()

Execute algorithem.

Returns:

int success flag, 0: success, -1: fail

prob_tuple getResult()

Get calculation result of the algorithem.

Returns:

prob_tuple calculation result

class QPanda::QSVM

Quantum Support Vector Machines.

#include <QSVMAlgorithm.h>

class QSVM
{
public:
    // construction

    QSVM(std::vector<std::vector<double>> data);

    // methods

    bool run(std::vector<double> query_x);
};

class QPanda::ShorAlg

Overview

Shor Algorthm. More…

#include <Shor.h>

class ShorAlg
{
public:
    // construction

    ShorAlg(int target);

    // methods

    void set_decomposition_starter(int smallest_base);
    bool exec();
    std::pair<int, int> get_results();
};

Detailed Documentation

Shor Algorthm.

Construction

ShorAlg(int target)

Parameters:

target

the number to initialize the large number

Methods

void set_decomposition_starter(int smallest_base)

Parameters:

set	the smallest base, default = 2

bool exec()

execute the prime factorization for target number

Returns:

whether the process succeed

std::pair<int, int> get_results()

get the decomposition result

Returns:

get the decomposition result

QPanda2 Algorithm Group.

B_V_Algorithm

DJ_Algorithm

Grover_Algorithm

QAOA

QAlgChemiQ

// classes

class QPanda::QARM;
class QPanda::QITE;
class QPanda::QSVM;
class QPanda::ShorAlg;

Further Reading:

Components

ChemiQ

HamiltonianSimulation

MaxCutProblemGenerator

Operator

Optimizer

Utils

Core

QuantumCircuit

QuantumMachine

Utilities

Variational

VirtualQuantumProcessor

QAlg

B_V_Algorithm

DJ_Algorithm

Grover_Algorithm

QAOA

QAlgChemiQ

Reference and Index:

Global Namespace

namespace Base64

Overview

namespace Base64 {

// global functions

uint8_t uc_decode(uint8_t uc);
uint8_t uc_encode(uint8_t uc);
std::vector<uint8_t> encode(const void* input, size_t length);
std::vector<uint8_t> encode(const std::vector<uint8_t>& bin);
std::vector<uint8_t> decode(const void* input, size_t length);
std::vector<uint8_t> decode(const std::vector<uint8_t>& input);

} // namespace Base64

Detailed Documentation

Global Functions

std::vector<uint8_t> encode(const void* input, size_t length)

Encodes supplied bytes into base64 encoded octets.

std::vector<uint8_t> encode(const std::vector<uint8_t>& bin)

Encodes supplied bytes into base64 encoded octets.

std::vector<uint8_t> decode(const void* input, size_t length)

Decodes supplied base64 encoded octets into raw bytes.

std::vector<uint8_t> decode(const std::vector<uint8_t>& input)

Decodes supplied base64 encoded octets into raw bytes.

namespace Eigen

namespace GATEGPU

struct GATEGPU::QState

#include <GPUStruct.h>

struct QState
{
    // fields

    gpu_qstate_t* real;
    gpu_qstate_t* imag;
    gpu_qsize_t qnum;
};

struct GATEGPU::probability

#include <GPUStruct.h>

struct probability
{
    // fields

    gpu_qstate_t prob;
    int state;
};

namespace GATEGPU {

// structs

struct QState;
struct probability;

// global functions

int devicecount();

bool initstate(
    QState& psi,
    QState& psigpu,
    size_t
    );

bool destroyState(
    QState& psi,
    QState& psigpu,
    size_t sQnum
    );

bool clearState(
    QState& psi,
    QState& psigpu,
    size_t sQnum
    );

bool Hadamard(
    QState& psi,
    size_t qn,
    bool isConjugate,
    double error_rate = 0
    );

bool Hadamardnew(
    QState& psi,
    size_t qn,
    bool isConjugate,
    double error_rate = 0
    );

bool controlHadamard(
    QState& psi,
    Qnum&,
    bool isConjugate,
    double error_rate = 0
    );

bool X(
    QState& psi,
    size_t qn,
    bool isConjugate,
    double error_rate = 0
    );

bool controlX(
    QState& psi,
    Qnum&,
    bool isConjugate,
    double error_rate = 0
    );

bool Y(
    QState& psi,
    size_t qn,
    bool isConjugate,
    double error_rate = 0
    );

bool controlY(
    QState& psi,
    Qnum&,
    bool isConjugate,
    double error_rate = 0
    );

bool Z(
    QState& psi,
    size_t qn,
    bool isConjugate,
    double error_rate = 0
    );

bool controlZ(
    QState& psi,
    Qnum&,
    bool isConjugate,
    double error_rate = 0
    );

bool S(
    QState& psi,
    size_t qn,
    bool isConjugate,
    double error_rate = 0
    );

bool controlS(
    QState& psi,
    Qnum&,
    bool isConjugate,
    double error_rate = 0
    );

bool T(
    QState& psi,
    size_t qn,
    bool isConjugate,
    double error_rate = 0
    );

bool controlT(
    QState& psi,
    Qnum&,
    bool isConjugate,
    double error_rate = 0
    );

bool RX(
    QState& psi,
    size_t qn,
    double theta,
    bool isConjugate,
    double error_rate = 0
    );

bool controlRX(
    QState& psi,
    Qnum&,
    double theta,
    bool isConjugate,
    double error_rate = 0
    );

bool RY(
    QState& psi,
    size_t qn,
    double theta,
    bool isConjugate,
    double error_rate = 0
    );

bool controlRY(
    QState& psi,
    Qnum&,
    double theta,
    bool isConjugate,
    double error_rate = 0
    );

bool RZ(
    QState& psi,
    size_t qn,
    double theta,
    bool isConjugate,
    double error_rate = 0
    );

bool controlRZ(
    QState& psi,
    Qnum&,
    double theta,
    bool isConjugate,
    double error_rate = 0
    );

bool CNOT(
    QState& psi,
    size_t qn_0,
    size_t qn_1,
    bool isConjugate,
    double error_rate = 0
    );

bool controlCNOT(
    QState& psi,
    size_t qn_0,
    size_t qn_1,
    Qnum&,
    bool isConjugate,
    double error_rate = 0
    );

bool CZ(
    QState& psi,
    size_t qn_0,
    size_t qn_1,
    bool isConjugate,
    double error_rate = 0
    );

bool controlCZ(
    QState& psi,
    size_t qn_0,
    size_t qn_1,
    Qnum&,
    bool isConjugate,
    double error_rate = 0
    );

bool CR(
    QState& psi,
    size_t qn_0,
    size_t qn_1,
    double thete,
    bool isConjugate,
    double error_rate = 0
    );

bool controlCR(
    QState& psi,
    size_t qn_0,
    size_t qn_1,
    Qnum&,
    double theta,
    bool isConjugate,
    double error_rate = 0
    );

bool iSWAP(
    QState& psi,
    size_t qn_0,
    size_t qn_1,
    double thete,
    bool isConjugate,
    double error_rate = 0
    );

bool controliSWAP(
    QState& psi,
    size_t qn_0,
    size_t qn_1,
    Qnum&,
    double theta,
    bool isConjugate,
    double error_rate = 0
    );

bool unitarysingle(
    QState& psi,
    size_t qn,
    QState& matr,
    bool isConjugate,
    double error_rate = 0
    );

bool controlunitarysingle(
    QState& psi,
    Qnum&,
    QState& matr,
    bool isConjugate,
    double error_rate = 0
    );

bool unitarydouble(
    QState& psi,
    size_t qn_0,
    size_t qn_1,
    QState& matr,
    bool isConjugate,
    double error_rate = 0
    );

bool controlunitarydouble(
    QState& psi,
    Qnum&,
    QState& matr,
    bool isConjugate,
    double error_rate = 0
    );

bool qbReset(
    QState& psi,
    size_t,
    double error_rate = 0
    );

bool pMeasurenew(
    QState&,
    touple_prob&,
    Qnum&,
    int
    );

bool getState(
    QState& psi,
    QState& psigpu,
    size_t qnum
    );

int qubitmeasure(
    QState& psigpu,
    gpu_qsize_t Block,
    gpu_qstate_t* resultgpu,
    gpu_qstate_t* probgpu
    );

bool pMeasure_no_index(
    QState&,
    vec_prob& mResult,
    Qnum&
    );

void gpuFree(void* memory);

} // namespace GATEGPU

namespace QGATE_SPACE

class QGATE_SPACE::AbstractSingleAngleParameter

#include <QuantumGate.h>

class AbstractSingleAngleParameter
{
public:
    // methods

    virtual double getParameter() const = 0;
};

// direct descendants

class CPHASE;
class ISWAPTheta;
class RX;
class RY;
class RZ;
class U1;

class QGATE_SPACE::BARRIER

#include <QuantumGate.h>

class BARRIER:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    BARRIER(QuantumGate* gate_old);
    BARRIER();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::CNOT

#include <QuantumGate.h>

class CNOT:
    public QGATE_SPACE::CU,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    CNOT(QuantumGate* gate_old);
    CNOT();
    CNOT(const CNOT&);
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    static T* CreateObject(Targs&&... args);
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat&) const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;

class QGATE_SPACE::CPHASE

#include <QuantumGate.h>

class CPHASE:
    public QGATE_SPACE::CU,
    public QGATE_SPACE::AbstractSingleAngleParameter,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    CPHASE(QuantumGate* gate_old);
    CPHASE(double);

    // methods

    virtual double getParameter() const;
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    static T* CreateObject(Targs&&... args);
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat&) const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual double getParameter() const = 0;

class QGATE_SPACE::CU

#include <QuantumGate.h>

class CU:
    public QGATE_SPACE::QDoubleGate,
    public QGATE_SPACE::AbstractAngleParameter,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    CU(QuantumGate* gate_old);
    CU();
    CU(const CU&);

    CU(
        double,
        double,
        double,
        double
        );

    CU(QStat& matrix);

    // methods

    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
};

// direct descendants

class CNOT;
class CPHASE;
class CZ;

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    static T* CreateObject(Targs&&... args);
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat&) const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;

class QGATE_SPACE::CZ

#include <QuantumGate.h>

class CZ:
    public QGATE_SPACE::CU,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    CZ(QuantumGate* gate_old);
    CZ();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    static T* CreateObject(Targs&&... args);
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat&) const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;

template class QGATE_SPACE::DynamicCreator

struct QGATE_SPACE::DynamicCreator::Register

#include <QuantumGate.h>

struct Register
{
    // methods

    void do_nothing() const;
};

#include <QuantumGate.h>

template <typename T, typename ... Targs>
class DynamicCreator
{
public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    static T* CreateObject(Targs&&... args);
};

// direct descendants

class BARRIER;
class BARRIER;
class CNOT;
class CNOT;
class CPHASE;
class CPHASE;
class CU;
class CU;
class CU;
class CZ;
class CZ;
class ECHO;
class ECHO;
class H;
class H;
class I;
class I;
class ISWAP;
class ISWAP;
class ISWAPTheta;
class ISWAPTheta;
class OracularGate;
class OracularGate;
class QDoubleGate;
class QDoubleGate;
class RPhi;
class RPhi;
class RX;
class RX;
class RY;
class RY;
class RZ;
class RZ;
class S;
class S;
class SQISWAP;
class SQISWAP;
class SWAP;
class SWAP;
class T;
class T;
class U1;
class U1;
class U2;
class U2;
class U3;
class U3;
class U4;
class U4;
class U4;
class X;
class X;
class X1;
class X1;
class Y;
class Y;
class Y1;
class Y1;
class Z;
class Z;
class Z1;
class Z1;

class QGATE_SPACE::ECHO

#include <QuantumGate.h>

class ECHO:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    ECHO(QuantumGate* gate_old);
    ECHO();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::H

#include <QuantumGate.h>

class H:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    H(QuantumGate* gate_old);
    H();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::I

#include <QuantumGate.h>

class I:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    I();
    I(QuantumGate* gate_old);
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::ISWAP

#include <QuantumGate.h>

class ISWAP:
    public QGATE_SPACE::QDoubleGate,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    ISWAP(QuantumGate* gate_old);
    ISWAP();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    static T* CreateObject(Targs&&... args);
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat&) const;

class QGATE_SPACE::ISWAPTheta

#include <QuantumGate.h>

class ISWAPTheta:
    public QGATE_SPACE::QDoubleGate,
    public QGATE_SPACE::AbstractSingleAngleParameter,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    ISWAPTheta(QuantumGate* gate_old);
    ISWAPTheta(double);

    // methods

    virtual double getParameter() const;
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    static T* CreateObject(Targs&&... args);
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat&) const;
    virtual double getParameter() const = 0;

class QGATE_SPACE::OracularGate

#include <QuantumGate.h>

class OracularGate:
    public QGATE_SPACE::QuantumGate,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    OracularGate(std::string name);
    OracularGate(QuantumGate* qgate_old);

    // methods

    std::string get_name() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    static T* CreateObject(Targs&&... args);

class QGATE_SPACE::QDoubleGate

#include <QuantumGate.h>

class QDoubleGate:
    public QGATE_SPACE::QuantumGate,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    QDoubleGate(QuantumGate* gate_old);
    QDoubleGate();
    QDoubleGate(const QDoubleGate& oldDouble);
    QDoubleGate(QStat& matrix);

    // methods

    virtual int getOperationNum() const;
    virtual void getMatrix(QStat&) const;
};

// direct descendants

class CU;
class ISWAP;
class ISWAPTheta;
class SQISWAP;
class SWAP;

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    static T* CreateObject(Targs&&... args);

class QGATE_SPACE::RPhi

#include <QuantumGate.h>

class RPhi:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    RPhi(QuantumGate* gate_old);

    RPhi(
        double,
        double
        );

    // methods

    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    double get_phi() const;
    double get_theta() const;
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::RX

#include <QuantumGate.h>

class RX:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::AbstractSingleAngleParameter,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    RX(QuantumGate* gate_old);
    RX(double);

    // methods

    virtual double getParameter() const;
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;
    virtual double getParameter() const = 0;

class QGATE_SPACE::RY

#include <QuantumGate.h>

class RY:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::AbstractSingleAngleParameter,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    RY(QuantumGate* gate_old);
    RY(double);

    // methods

    virtual double getParameter() const;
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;
    virtual double getParameter() const = 0;

class QGATE_SPACE::RZ

#include <QuantumGate.h>

class RZ:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::AbstractSingleAngleParameter,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    RZ(QuantumGate* gate_old);
    RZ(double);

    // methods

    virtual double getParameter() const;
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;
    virtual double getParameter() const = 0;

class QGATE_SPACE::S

#include <QuantumGate.h>

class S:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    S(QuantumGate* gate_old);
    S();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::SQISWAP

#include <QuantumGate.h>

class SQISWAP:
    public QGATE_SPACE::QDoubleGate,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // fields

    double theta;

    // construction

    SQISWAP(QuantumGate* gate_old);
    SQISWAP();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    static T* CreateObject(Targs&&... args);
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat&) const;

class QGATE_SPACE::SWAP

#include <QuantumGate.h>

class SWAP:
    public QGATE_SPACE::QDoubleGate,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    SWAP(QuantumGate* gate_old);
    SWAP();

    // methods

    virtual int getGateType() const;
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    static T* CreateObject(Targs&&... args);
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat&) const;

class QGATE_SPACE::T

#include <QuantumGate.h>

class T:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    T(QuantumGate* gate_old);
    T();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::U1

#include <QuantumGate.h>

class U1:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::AbstractSingleAngleParameter,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    U1(QuantumGate* gate_old);
    U1(double);

    // methods

    virtual double getParameter() const;
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;
    virtual double getParameter() const = 0;

class QGATE_SPACE::U2

#include <QuantumGate.h>

class U2:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    U2(QuantumGate* gate_old);

    U2(
        double,
        double
        );

    // methods

    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    double get_phi() const;
    double get_lambda() const;
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::U3

#include <QuantumGate.h>

class U3:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    U3(QuantumGate* gate_old);

    U3(
        double,
        double,
        double
        );

    // methods

    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    double get_theta() const;
    double get_phi() const;
    double get_lambda() const;
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::U4

#include <QuantumGate.h>

class U4:
    public QGATE_SPACE::QuantumGate,
    public QGATE_SPACE::AbstractAngleParameter,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    U4();
    U4(U4&);

    U4(
        double,
        double,
        double,
        double
        );

    U4(QStat& matrix);
    U4(QuantumGate*);

    // methods

    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;
};

// direct descendants

class BARRIER;
class ECHO;
class H;
class I;
class RPhi;
class RX;
class RY;
class RZ;
class S;
class T;
class U1;
class U2;
class U3;
class X;
class X1;
class Y;
class Y1;
class Z;
class Z1;

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);

class QGATE_SPACE::X

#include <QuantumGate.h>

class X:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    X();
    X(QuantumGate* gate_old);
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::X1

#include <QuantumGate.h>

class X1:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    X1(QuantumGate* gate_old);
    X1();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::Y

#include <QuantumGate.h>

class Y:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    Y(QuantumGate* gate_old);
    Y();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::Y1

#include <QuantumGate.h>

class Y1:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    Y1(QuantumGate* gate_old);
    Y1();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::Z

#include <QuantumGate.h>

class Z:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    Z(QuantumGate* gate_old);
    Z();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

class QGATE_SPACE::Z1

#include <QuantumGate.h>

class Z1:
    public QGATE_SPACE::U4,
    public QGATE_SPACE::DynamicCreator,
    public QGATE_SPACE::DynamicCreator
{
public:
    // construction

    Z1(QuantumGate* gate_old);
    Z1();
};

Inherited Members

public:
    // structs

    struct Register;

    // fields

    static Register m_register;

    // methods

    virtual int getOperationNum() const = 0;
    virtual void getMatrix(QStat& matrix) const = 0;
    virtual int getGateType() const;
    virtual double getAlpha() const = 0;
    virtual double getBeta() const = 0;
    virtual double getGamma() const = 0;
    virtual double getDelta() const = 0;
    static T* CreateObject(Targs&&... args);
    virtual double getAlpha() const;
    virtual double getBeta() const;
    virtual double getGamma() const;
    virtual double getDelta() const;
    virtual int getOperationNum() const;
    virtual void getMatrix(QStat& matrix) const;

QGATE namespace.

namespace QGATE_SPACE {

// classes

class AbstractAngleParameter;
class AbstractSingleAngleParameter;
class BARRIER;
class CNOT;
class CPHASE;
class CU;
class CZ;

template <typename T, typename ... Targs>
class DynamicCreator;

class ECHO;
class H;
class I;
class ISWAP;
class ISWAPTheta;
class OracularGate;
class QDoubleGate;

template <typename ... Targs>
class QGateFactory;

class QuantumGate;
class RPhi;
class RX;
class RY;
class RZ;
class S;
class SQISWAP;
class SWAP;
class T;
class U1;
class U2;
class U3;
class U4;
class X;
class X1;
class Y;
class Y1;
class Z;
class Z1;

// global functions

template <typename ... Targs>
QuantumGate* create_quantum_gate(
    const std::string& type_name,
    Targs&&... args
    );

} // namespace QGATE_SPACE

namespace QPanda

namespace QPanda::DRAW_TEXT_PIC

enum QPanda::DRAW_TEXT_PIC::TEXT_PIC_TYPE

Overview

#include <Draw.h>

enum TEXT_PIC_TYPE
{
    LAYER         = 0,
    TIME_SEQUENCE,
};

Detailed Documentation

Enum Values

LAYER

draw text-picture by layer

TIME_SEQUENCE

draw text-picture by time sequence

template class QPanda::DRAW_TEXT_PIC::AbstractHandleNodes

Overview

node handle More…

#include <Draw.h>

template <typename... Args>
class AbstractHandleNodes
{
public:
    // methods

    virtual void handle_measure_node(Args&&... func_args) = 0;
    virtual void handle_reset_node(Args&&... func_args) = 0;
    virtual void handle_gate_node(Args&&... func_args) = 0;
    virtual void handle_work(const NodeType node_t, Args&&... func_args);
};

// direct descendants

class DrawByLayer;
class FillLayerByNextLayerNodes;
class GetUsedQubits;

Detailed Documentation

node handle

Methods

virtual void handle_measure_node(Args&&... func_args) = 0

handle measure node

virtual void handle_reset_node(Args&&... func_args) = 0

handle reset node

virtual void handle_gate_node(Args&&... func_args) = 0

handle gate node

virtual void handle_work(const NodeType node_t, Args&&... func_args)

handle work run

class QPanda::DRAW_TEXT_PIC::DrawBox

Overview

Draw text-picture box. More…

#include <Draw.h>

class DrawBox
{
public:
    // construction

    DrawBox(
        const std::string& top_format_str,
        const std::string& mid_format_str,
        const std::string& bot_format_str
        );

    // methods

    virtual const std::string& getTopStr() const;
    virtual const std::string& getMidStr() const;
    virtual const std::string& getBotStr() const;
    virtual void set_top_connected();
    virtual void set_bot_connected();
    virtual int getLen() const = 0;
};

Detailed Documentation

Draw text-picture box.

Construction

DrawBox(
    const std::string& top_format_str,
    const std::string& mid_format_str,
    const std::string& bot_format_str
    )

Constructor of DrawBox.

Methods

virtual const std::string& getTopStr() const

get top string of box

virtual const std::string& getMidStr() const

get middle string of box

virtual const std::string& getBotStr() const

get bottom string of box

virtual void set_top_connected()

set connected str on the top of box

virtual void set_bot_connected()

set connected str on the bottom of box

virtual int getLen() const = 0

get box len

Returns:

int the length of box

class QPanda::DRAW_TEXT_PIC::DrawByLayer

draw layer nodes

#include <Draw.h>

class DrawByLayer: public QPanda::DRAW_TEXT_PIC::AbstractHandleNodes
{
public:
    // construction

    DrawByLayer(DrawPicture& parent);

    // methods

    void handle_measure_node(
        std::shared_ptr<QNode>& p_node,
        pOptimizerNodeInfo& p_node_info
        );

    void handle_reset_node(
        std::shared_ptr<QNode>& p_node,
        pOptimizerNodeInfo& p_node_info
        );

    void handle_gate_node(
        std::shared_ptr<QNode>& p_node,
        pOptimizerNodeInfo& p_node_info
        );
};

Inherited Members

public:
    // methods

    virtual void handle_measure_node(Args&&... func_args) = 0;
    virtual void handle_reset_node(Args&&... func_args) = 0;
    virtual void handle_gate_node(Args&&... func_args) = 0;
    virtual void handle_work(const NodeType node_t, Args&&... func_args);

class QPanda::DRAW_TEXT_PIC::DrawPicture

Overview

draw text-picture More…

#include <Draw.h>

class DrawPicture
{
public:
    // construction

    DrawPicture(QProg prog, LayeredTopoSeq& layer_info, uint32_t length);

    // methods

    void init(std::vector<int>& quBits, std::vector<int>& clBits);
    std::string present(bool b_out_put_to_file = false);
    void mergeLine();
    int getMaxQuWireLength(WireIter start_quBit_wire, WireIter end_quBit_wire);
    void updateTextPicLen();
    unsigned long getWideCharVal(const unsigned char* wide_char);
    void check_time_sequence(TopoSeqIter cur_layer_iter);
    void update_time_sequence(Wire::sRef& p_wire, int increased_time_sequence);
    void append_time_sequence_line();
    void append_layer_line();
    void draw_by_layer();
    void draw_by_time_sequence(const std::string config_data = CONFIG_PATH);
    QVec get_qvec_difference(QVec& vec1, QVec& vec2);
};

Detailed Documentation

draw text-picture

Construction

DrawPicture(QProg prog, LayeredTopoSeq& layer_info, uint32_t length)

Constructor of DrawPicture.

Methods

void init(std::vector<int>& quBits, std::vector<int>& clBits)

initialize

Parameters:

std::vector<int>&	used qubits
std::vector<int>&	used class bits

std::string present(bool b_out_put_to_file = false)

display and return the target string

Returns:

std::string

void mergeLine()

merge wire line

int getMaxQuWireLength(WireIter start_quBit_wire, WireIter end_quBit_wire)

get the max length of quantum wire between start_quBit_wire and end_quBit_wire

Parameters:

WireIter	start quBit wire
WireIter	end quBit wire

Returns:

int the max length

void updateTextPicLen()

update TextPic length

unsigned long getWideCharVal(const unsigned char* wide_char)

get val of wide char

Parameters:

unsigned char*

the target wide char

Returns:

the val of the wide char

void check_time_sequence(TopoSeqIter cur_layer_iter)

check the target wire time sequence

Parameters:

TopoSeqIter

the target layer

void update_time_sequence(Wire::sRef& p_wire, int increased_time_sequence)

update the target wire time sequence

Parameters:

std::shared_ptr<Wire>	the target wire
int	increased time sequence

void append_time_sequence_line()

append time sequence line to text-picture

void append_layer_line()

append layer line to text-picture

void draw_by_layer()

draw text-picture by layer

void draw_by_time_sequence(const std::string config_data = CONFIG_PATH)

draw text-picture by time sequence

Parameters:

const

std::string It can be configuration file or configuration data, which can be distinguished by file suffix, so the configuration file must be end with “.json”, default is CONFIG_PATH

QVec get_qvec_difference(QVec& vec1, QVec& vec2)

get the difference of two QVecs

Returns:

QVec vec1 - vec2

class QPanda::DRAW_TEXT_PIC::FillLayerByNextLayerNodes

Overview

Fill layer by next layer nodes. More…

#include <Draw.h>

class FillLayerByNextLayerNodes: public QPanda::DRAW_TEXT_PIC::AbstractHandleNodes
{
public:
    // construction

    FillLayerByNextLayerNodes(
        DrawPicture& parent,
        QVec& unused_qubits_vec,
        TopoSeqLayer& target_layer,
        TopoSeqLayer& next_layer
        );

    // methods

    void handle_measure_node(TopoSeqLayerIter& itr_on_next_layer);
    void handle_reset_node(TopoSeqLayerIter& itr_on_next_layer);
    void handle_gate_node(TopoSeqLayerIter& itr_on_next_layer);
    bool have_got_available_node();
};

Inherited Members

public:
    // methods

    virtual void handle_measure_node(Args&&... func_args) = 0;
    virtual void handle_reset_node(Args&&... func_args) = 0;
    virtual void handle_gate_node(Args&&... func_args) = 0;
    virtual void handle_work(const NodeType node_t, Args&&... func_args);

Detailed Documentation

Fill layer by next layer nodes.

Methods

bool have_got_available_node()

judge whether get available node

Returns:

bool if got available node, return true, or else return false

class QPanda::DRAW_TEXT_PIC::GetUsedQubits

get all used qubits

#include <Draw.h>

class GetUsedQubits: public QPanda::DRAW_TEXT_PIC::AbstractHandleNodes
{
public:
    // construction

    GetUsedQubits(
        DrawPicture& parent,
        QVec& vec
        );

    // methods

    void handle_measure_node(std::shared_ptr<QNode>& p_node);
    void handle_reset_node(std::shared_ptr<QNode>& p_node);
    void handle_gate_node(std::shared_ptr<QNode>& p_node);
};

Inherited Members

public:
    // methods

    virtual void handle_measure_node(Args&&... func_args) = 0;
    virtual void handle_reset_node(Args&&... func_args) = 0;
    virtual void handle_gate_node(Args&&... func_args) = 0;
    virtual void handle_work(const NodeType node_t, Args&&... func_args);

class QPanda::DRAW_TEXT_PIC::Wire

Overview

the wire of text-picture More…

#include <Draw.h>

class Wire
{
public:
    // typedefs

    typedef std::shared_ptr<Wire> sRef;

    // construction

    Wire(const std::string& connect_str);

    // methods

    virtual void setName(const std::string& name, size_t nameLen);
    virtual int append(const DrawBox& box, const int box_pos);
    virtual int getWireLength();
    virtual std::string draw();
    virtual void updateWireLen(const int len);
    virtual void setMergedFlag(bool b);
    virtual const std::string& getTopLine() const;
    virtual const std::string& getMidLine() const;
    virtual const std::string& getBotLine() const;
    int update_time_sequence(unsigned int increase_time_sequence);
    int get_time_sequence();
};

Detailed Documentation

the wire of text-picture

Construction

Wire(const std::string& connect_str)

Constructor of DrawBox.

Methods

virtual void setName(const std::string& name, size_t nameLen)

set the name of wire

Parameters:

std::string&	name
size_t	name length

virtual int append(const DrawBox& box, const int box_pos)

append a box to current wire

Parameters:

DrawBox&	box
int	append postion

Returns:

int the length of current wire

virtual int getWireLength()

get the length of current wire

Returns:

int the length of current wire

virtual std::string draw()

conver current wire to string and save to file

Returns:

std::string

virtual void updateWireLen(const int len)

update current wire length

Parameters:

int	the new length

virtual void setMergedFlag(bool b)

set whether to merge wire

Parameters:

bool

virtual const std::string& getTopLine() const

get top line string

Returns:

std::string

virtual const std::string& getMidLine() const

get middle line string

Returns:

std::string

virtual const std::string& getBotLine() const

get bottom line string

Returns:

std::string

int update_time_sequence(unsigned int increase_time_sequence)

update current wire time sequence

Parameters:

int	the increased time sequence

int get_time_sequence()

get current wire time sequence

Returns:

int

namespace DRAW_TEXT_PIC {

// typedefs

typedef LayeredTopoSeq TopoSeq;
typedef LayeredTopoSeq::iterator TopoSeqIter;
typedef SeqLayer<pOptimizerNodeInfo> TopoSeqLayer;
typedef SeqLayer<pOptimizerNodeInfo>::iterator TopoSeqLayerIter;

// enums

enum TEXT_PIC_TYPE;

// classes

template <typename... Args>
class AbstractHandleNodes;

class DrawBox;
class DrawByLayer;
class DrawPicture;
class DrawQProg;
class FillLayerByNextLayerNodes;
class GetUsedQubits;
class Wire;

} // namespace DRAW_TEXT_PIC

namespace QPanda::Variational

enum QPanda::Variational::OptimizerMode

#include <Optimizer.h>

enum OptimizerMode
{
    MINIMIZE,
    MAXIMIZE,
};

enum QPanda::Variational::back_flags

#include <utils.h>

enum back_flags
{
    const_qualify,
};

enum QPanda::Variational::op_type

enum class of operator types

#include <var.h>

enum op_type
{
    plus,
    minus,
    multiply,
    divide,
    exponent,
    log,
    polynomial,
    dot,
    inverse,
    transpose,
    sum,
    stack,
    subscript,
    qop,
    qop_pmeasure,
    qop_real_chip,
    qop_pmeasure_real_chip,
    sigmoid,
    softmax,
    cross_entropy,
    dropout,
    none,
};

struct QPanda::Variational::impl

Overview

implementation class for the var. Impl only includes classical operator with fixed number of arguments. More…

#include <var.h>

struct impl
{
    // fields

    MatrixXd val;
    bool m_is_differentiable;
    op_type op;
    std::vector<var> children;
    std::vector<std::weak_ptr<impl>> parents;
    MatrixXd m_prob;

    // construction

    impl(const MatrixXd&);

    impl(
        const MatrixXd&,
        bool isDifferentiable
        );

    impl(op_type, const std::vector<var>&);
};

// direct descendants

struct impl_qop_pmeasure;
struct impl_qop_pmeasure_real_chip;
struct impl_stack;
struct impl_subscript;
struct impl_vqp;
struct impl_vqp_real_chip;

Detailed Documentation

implementation class for the var. Impl only includes classical operator with fixed number of arguments.

Fields

MatrixXd val

Internal value.

bool m_is_differentiable

Placeholder/Variable.

op_type op

Operator type.

std::vector<var> children

Childrens. For example, c = a + b. c is a and b’s parent, a and b are c’s children.

std::vector<std::weak_ptr<impl>> parents

Parents. For example, c = a + b. c is a and b’s parent, a and b are c’s children.

MatrixXd m_prob

Internal value.

Construction

impl(const MatrixXd&)

Construct from a Eigen matrix.

impl(op_type, const std::vector<var>&)

Construct from a operator.

struct QPanda::Variational::impl_qop_pmeasure

#include <var.h>

struct impl_qop_pmeasure: public QPanda::Variational::impl
{
    // construction

    impl_qop_pmeasure(
        VariationalQuantumCircuit,
        std::vector<size_t>,
        QuantumMachine*,
        std::vector<Qubit*>
        );

    // methods

    std::vector<double> _get_gradient(var _var);
    std::vector<double> _get_value();
    std::vector<double> _get_circuit_value(QCircuit);
};

Inherited Members

public:
    // fields

    MatrixXd val;
    bool m_is_differentiable;
    op_type op;
    std::vector<var> children;
    std::vector<std::weak_ptr<impl>> parents;
    MatrixXd m_prob;

struct QPanda::Variational::impl_qop_pmeasure_real_chip

#include <var.h>

struct impl_qop_pmeasure_real_chip: public QPanda::Variational::impl
{
    // construction

    impl_qop_pmeasure_real_chip(
        VariationalQuantumCircuit,
        std::vector<size_t>,
        QuantumMachine*,
        std::vector<Qubit*>,
        std::vector<ClassicalCondition>,
        size_t shots
        );

    // methods

    std::vector<double> _get_gradient(var _var);
    std::vector<double> _get_value();
    std::vector<double> _get_circuit_value(QCircuit);
};

Inherited Members

public:
    // fields

    MatrixXd val;
    bool m_is_differentiable;
    op_type op;
    std::vector<var> children;
    std::vector<std::weak_ptr<impl>> parents;
    MatrixXd m_prob;

struct QPanda::Variational::impl_stack

Overview

Implementation class for the stack operation. More…

#include <var.h>

struct impl_stack: public QPanda::Variational::impl
{
    // fields

    int m_axis;

    // construction

    impl_stack(int axis, const std::vector<var>&);
};

Inherited Members

public:
    // fields

    MatrixXd val;
    bool m_is_differentiable;
    op_type op;
    std::vector<var> children;
    std::vector<std::weak_ptr<impl>> parents;
    MatrixXd m_prob;

Detailed Documentation

Implementation class for the stack operation.

Fields

int m_axis

stack axis, should be either 0 or 1.

Construction

impl_stack(int axis, const std::vector<var>&)

Construct a new impl stack object by the axis and children. y = stack(axis=0, [a,b,c,d]). It will try to place a,b,c,d into one matrix with the same columns, if axis==1, the same rows.

Parameters:

axis	the stack axis.

struct QPanda::Variational::impl_subscript

Overview

implementation for the subscript operation. More…

#include <var.h>

struct impl_subscript: public QPanda::Variational::impl
{
    // fields

    int m_subscript;

    // construction

    impl_subscript(int subscript, const std::vector<var>&);
};

Inherited Members

public:
    // fields

    MatrixXd val;
    bool m_is_differentiable;
    op_type op;
    std::vector<var> children;
    std::vector<std::weak_ptr<impl>> parents;
    MatrixXd m_prob;

Detailed Documentation

implementation for the subscript operation.

Fields

int m_subscript

the subscript

Construction

impl_subscript(int subscript, const std::vector<var>&)

Construct a new impl subscript object by child and the subscript. c = a[i], subscript=i, a=children and c=parent.

Parameters:

subscript

the subscript.

struct QPanda::Variational::impl_vqp

#include <var.h>

struct impl_vqp: public QPanda::Variational::impl
{
    // construction

    impl_vqp(
        VariationalQuantumCircuit,
        PauliOperator,
        QuantumMachine*,
        std::vector<Qubit*>
        );

    impl_vqp(
        VariationalQuantumCircuit,
        PauliOperator,
        QuantumMachine*,
        std::map<size_t, Qubit*>
        );

    // methods

    double _get_gradient(var _var);

    double _get_gradient_one_term(
        var _var,
        QTerm
        );

    double _get_expectation_one_term(
        QCircuit,
        QTerm
        );

    double _get_expectation();
};

Inherited Members

public:
    // fields

    MatrixXd val;
    bool m_is_differentiable;
    op_type op;
    std::vector<var> children;
    std::vector<std::weak_ptr<impl>> parents;
    MatrixXd m_prob;

struct QPanda::Variational::impl_vqp_real_chip

#include <var.h>

struct impl_vqp_real_chip: public QPanda::Variational::impl
{
    // construction

    impl_vqp_real_chip(
        VariationalQuantumCircuit,
        PauliOperator,
        QuantumMachine*,
        std::vector<Qubit*>,
        int shots
        );

    impl_vqp_real_chip(
        VariationalQuantumCircuit,
        PauliOperator,
        QuantumMachine*,
        std::map<size_t, Qubit*>,
        int shots
        );

    // methods

    double _get_gradient(var _var);

    double _get_gradient_one_term(
        var _var,
        QTerm
        );

    double _get_expectation_one_term(
        QCircuit,
        QTerm
        );

    double _get_expectation();
};

Inherited Members

public:
    // fields

    MatrixXd val;
    bool m_is_differentiable;
    op_type op;
    std::vector<var> children;
    std::vector<std::weak_ptr<impl>> parents;
    MatrixXd m_prob;

class QPanda::Variational::AdaGradOptimizer

#include <Optimizer.h>

class AdaGradOptimizer: public QPanda::Variational::Optimizer
{
public:
    // construction

    AdaGradOptimizer(
        var lost,
        double learning_rate = 0.01,
        double initial_accumulator_value = 0.0,
        double epsilon = 1e-10
        );

    // methods

    virtual std::unordered_map<var, MatrixXd> compute_gradients(std::unordered_set<var>& var_set);
    virtual std::unordered_set<var> get_variables();
    virtual double get_loss();

    virtual bool run(
        std::unordered_set<var>& leaves,
        size_t t = 0
        );

    static std::shared_ptr<Optimizer> minimize(
        var& lost,
        double learning_rate = 0.01,
        double initial_accumulator_value = 0.0,
        double epsilon = 1e-10
        );
};

Inherited Members

public:
    // methods

    virtual std::unordered_set<var> get_variables() = 0;
    virtual std::unordered_map<var, MatrixXd> compute_gradients(std::unordered_set<var>& var_set) = 0;
    virtual double get_loss() = 0;
    virtual bool run(std::unordered_set<var>& leaves, size_t t = 0) = 0;

class QPanda::Variational::AdamOptimizer

#include <Optimizer.h>

class AdamOptimizer: public QPanda::Variational::Optimizer
{
public:
    // construction

    AdamOptimizer(
        var lost,
        double learning_rate = 0.001,
        double beta1 = 0.9,
        double beta2 = 0.999,
        double epsilon = 1e-8
        );

    // methods

    virtual std::unordered_map<var, MatrixXd> compute_gradients(std::unordered_set<var>& var_set);
    virtual std::unordered_set<var> get_variables();
    virtual double get_loss();

    virtual bool run(
        std::unordered_set<var>& leaves,
        size_t t = 0
        );

    static std::shared_ptr<Optimizer> minimize(
        var& lost,
        double learning_rate = 0.001,
        double beta1 = 0.9,
        double beta2 = 0.999,
        double epsilon = 1e-10
        );
};

Inherited Members

public:
    // methods

    virtual std::unordered_set<var> get_variables() = 0;
    virtual std::unordered_map<var, MatrixXd> compute_gradients(std::unordered_set<var>& var_set) = 0;
    virtual double get_loss() = 0;
    virtual bool run(std::unordered_set<var>& leaves, size_t t = 0) = 0;

class QPanda::Variational::MomentumOptimizer

#include <Optimizer.h>

class MomentumOptimizer: public QPanda::Variational::Optimizer
{
public:
    // construction

    MomentumOptimizer(
        var lost,
        double learning_rate = 0.01,
        double momentum = 0.9
        );

    // methods

    virtual std::unordered_map<var, MatrixXd> compute_gradients(std::unordered_set<var>& var_set);
    virtual std::unordered_set<var> get_variables();
    virtual double get_loss();

    virtual bool run(
        std::unordered_set<var>& leaves,
        size_t t = 0
        );

    static std::shared_ptr<Optimizer> minimize(
        var& lost,
        double learning_rate = 0.01,
        double momentum = 0.9
        );
};

Inherited Members

public:
    // methods

    virtual std::unordered_set<var> get_variables() = 0;
    virtual std::unordered_map<var, MatrixXd> compute_gradients(std::unordered_set<var>& var_set) = 0;
    virtual double get_loss() = 0;
    virtual bool run(std::unordered_set<var>& leaves, size_t t = 0) = 0;

class QPanda::Variational::RMSPropOptimizer

#include <Optimizer.h>

class RMSPropOptimizer: public QPanda::Variational::Optimizer
{
public:
    // construction

    RMSPropOptimizer(
        var lost,
        double learning_rate = 0.001,
        double decay = 0.9,
        double epsilon = 1e-10
        );

    // methods

    virtual std::unordered_map<var, MatrixXd> compute_gradients(std::unordered_set<var>& var_set);
    virtual std::unordered_set<var> get_variables();
    virtual double get_loss();

    virtual bool run(
        std::unordered_set<var>& leaves,
        size_t t = 0
        );

    static std::shared_ptr<Optimizer> minimize(
        var& lost,
        double learning_rate = 0.001,
        double decay = 0.9,
        double epsilon = 1e-10
        );
};

Inherited Members

public:
    // methods

    virtual std::unordered_set<var> get_variables() = 0;
    virtual std::unordered_map<var, MatrixXd> compute_gradients(std::unordered_set<var>& var_set) = 0;
    virtual double get_loss() = 0;
    virtual bool run(std::unordered_set<var>& leaves, size_t t = 0) = 0;

class QPanda::Variational::VanillaGradientDescentOptimizer

#include <Optimizer.h>

class VanillaGradientDescentOptimizer: public QPanda::Variational::Optimizer
{
public:
    // construction

    VanillaGradientDescentOptimizer(
        var lost_function,
        double learning_rate = 0.01,
        double stop_condition = 1.e-6,
        OptimizerMode mode = OptimizerMode::MINIMIZE
        );

    // methods

    virtual std::unordered_set<var> get_variables();
    virtual std::unordered_map<var, MatrixXd> compute_gradients(std::unordered_set<var>& var_set);
    virtual double get_loss();

    virtual bool run(
        std::unordered_set<var>& leaves,
        size_t t = 0
        );

    static std::shared_ptr<Optimizer> minimize(
        var,
        double,
        double
        );
};

Inherited Members

public:
    // methods

    virtual std::unordered_set<var> get_variables() = 0;
    virtual std::unordered_map<var, MatrixXd> compute_gradients(std::unordered_set<var>& var_set) = 0;
    virtual double get_loss() = 0;
    virtual bool run(std::unordered_set<var>& leaves, size_t t = 0) = 0;

class QPanda::Variational::VariationalQuantumCircuit

#include <var.h>

class VariationalQuantumCircuit
{
public:
    // construction

    VariationalQuantumCircuit();
    VariationalQuantumCircuit(const VariationalQuantumCircuit&);
    VariationalQuantumCircuit(QCircuit);

    // methods

    std::vector<var>& get_vars();
    QCircuit feed(const std::vector<std::tuple<std::weak_ptr<VariationalQuantumGate>, size_t, double>>) const;
    QCircuit feed();
    std::vector<std::weak_ptr<VariationalQuantumGate>> get_var_in_which_gate(const var&) const;

    template <typename VQG_Ty>
    VariationalQuantumCircuit& insert(VQG_Ty gate);

    bool set_dagger(bool dagger);
    bool set_control(QVec control_qubit);
    bool is_dagger();
    QVec get_control_qubit();
    VariationalQuantumCircuit dagger();
    VariationalQuantumCircuit control(QVec qv);
    VariationalQuantumCircuit& insert(VariationalQuantumCircuit circuit);
    VariationalQuantumCircuit& insert(QGate& gate);
    VariationalQuantumCircuit& insert(QGate gate);
    VariationalQuantumCircuit& insert(QCircuit c);
};

class QPanda::Variational::VariationalQuantumGate

Overview

#include <var.h>

class VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate(const VariationalQuantumGate&);
    VariationalQuantumGate();

    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);
};

// direct descendants

class VariationalQuantumGate_CNOT;
class VariationalQuantumGate_CR;
class VariationalQuantumGate_CRX;
class VariationalQuantumGate_CRY;
class VariationalQuantumGate_CRZ;
class VariationalQuantumGate_CU;
class VariationalQuantumGate_CZ;
class VariationalQuantumGate_H;
class VariationalQuantumGate_iSWAP;
class VariationalQuantumGate_RPhi;
class VariationalQuantumGate_RX;
class VariationalQuantumGate_RY;
class VariationalQuantumGate_RZ;
class VariationalQuantumGate_S;
class VariationalQuantumGate_SqiSWAP;
class VariationalQuantumGate_SWAP;
class VariationalQuantumGate_T;
class VariationalQuantumGate_U1;
class VariationalQuantumGate_U2;
class VariationalQuantumGate_U3;
class VariationalQuantumGate_U4;
class VariationalQuantumGate_X;
class VariationalQuantumGate_X1;
class VariationalQuantumGate_Y;
class VariationalQuantumGate_Y1;
class VariationalQuantumGate_Z;
class VariationalQuantumGate_Z1;

Detailed Documentation

Construction

VariationalQuantumGate(const VariationalQuantumGate&)

Copy Constructor for a new Variational Quantum Gate object.

VariationalQuantumGate()

Default Constructor for a new Variational Quantum Gate object.

Methods

size_t n_var()

Returns:

size_t the number of vars.

const std::vector<var>& get_vars()

Get all variables for the VQG.

Returns:

std::vector<Variable>

int var_pos(var _var)

Get the position for var in the m_vars. If not existed, return -1. Otherwise, return the position n, which is var == m_vars[n].

Parameters:

var	The corresponding variable.

Returns:

int -1 if not existed, or position.

virtual QGate feed() = 0

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy() = 0

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_CNOT

Overview

#include <var.h>

class VariationalQuantumGate_CNOT: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_CNOT(
        Qubit*,
        Qubit*
        );

    VariationalQuantumGate_CNOT(const VariationalQuantumGate_CNOT& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_CNOT dagger();
    VariationalQuantumGate_CNOT control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_CR

Overview

#include <var.h>

class VariationalQuantumGate_CR: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_CR(
        Qubit*,
        Qubit*,
        var
        );

    VariationalQuantumGate_CR(
        Qubit*,
        Qubit*,
        double
        );

    VariationalQuantumGate_CR(const VariationalQuantumGate_CR& gate);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_CR dagger();
    VariationalQuantumGate_CR control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_CRX

Overview

#include <var.h>

class VariationalQuantumGate_CRX: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_CRX(
        Qubit*,
        QVec,
        var
        );

    VariationalQuantumGate_CRX(
        Qubit*,
        QVec,
        double angle
        );

    VariationalQuantumGate_CRX(const VariationalQuantumGate_CRX& old);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_CRX dagger();
    VariationalQuantumGate_CRX control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_CRY

Overview

#include <var.h>

class VariationalQuantumGate_CRY: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_CRY(
        Qubit*,
        QVec,
        var
        );

    VariationalQuantumGate_CRY(
        Qubit*,
        QVec,
        double angle
        );

    VariationalQuantumGate_CRY(const VariationalQuantumGate_CRY& old);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_CRY dagger();
    VariationalQuantumGate_CRY control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_CRZ

Overview

#include <var.h>

class VariationalQuantumGate_CRZ: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_CRZ(
        Qubit*,
        QVec,
        var
        );

    VariationalQuantumGate_CRZ(
        Qubit*,
        QVec,
        double angle
        );

    VariationalQuantumGate_CRZ(const VariationalQuantumGate_CRZ& old);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_CRZ dagger();
    VariationalQuantumGate_CRZ control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_CU

Overview

#include <var.h>

class VariationalQuantumGate_CU: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_CU(
        Qubit*,
        Qubit*,
        var,
        var,
        var,
        var
        );

    VariationalQuantumGate_CU(
        Qubit*,
        Qubit*,
        double,
        double,
        double,
        double
        );

    VariationalQuantumGate_CU(const VariationalQuantumGate_CU& gate);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_CU dagger();
    VariationalQuantumGate_CU control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_CZ

Overview

#include <var.h>

class VariationalQuantumGate_CZ: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_CZ(
        Qubit*,
        Qubit*
        );

    VariationalQuantumGate_CZ(const VariationalQuantumGate_CZ& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_CZ dagger();
    VariationalQuantumGate_CZ control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_H

Overview

#include <var.h>

class VariationalQuantumGate_H: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_H(Qubit* q);

    VariationalQuantumGate_H(
        Qubit* q,
        bool is_dagger
        );

    VariationalQuantumGate_H(
        Qubit* q,
        bool is_dagger,
        QVec control_qubit
        );

    VariationalQuantumGate_H(const VariationalQuantumGate_H& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_H dagger();
    VariationalQuantumGate_H control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_RPhi

Overview

#include <var.h>

class VariationalQuantumGate_RPhi: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_RPhi(
        Qubit*,
        var,
        var
        );

    VariationalQuantumGate_RPhi(
        Qubit*,
        double,
        double
        );

    VariationalQuantumGate_RPhi(const VariationalQuantumGate_RPhi& gate);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_RPhi dagger();
    VariationalQuantumGate_RPhi control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_RX

Overview

#include <var.h>

class VariationalQuantumGate_RX: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_RX(
        Qubit*,
        var
        );

    VariationalQuantumGate_RX(
        Qubit*,
        double angle
        );

    VariationalQuantumGate_RX(const VariationalQuantumGate_RX& gate);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_RX dagger();
    VariationalQuantumGate_RX control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_RY

Overview

#include <var.h>

class VariationalQuantumGate_RY: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_RY(
        Qubit*,
        var
        );

    VariationalQuantumGate_RY(
        Qubit*,
        double angle
        );

    VariationalQuantumGate_RY(const VariationalQuantumGate_RY& gate);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_RY dagger();
    VariationalQuantumGate_RY control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_RZ

Overview

#include <var.h>

class VariationalQuantumGate_RZ: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_RZ(
        Qubit*,
        var
        );

    VariationalQuantumGate_RZ(
        Qubit*,
        double angle
        );

    VariationalQuantumGate_RZ(const VariationalQuantumGate_RZ& gate);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_RZ dagger();
    VariationalQuantumGate_RZ control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_S

Overview

#include <var.h>

class VariationalQuantumGate_S: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_S(Qubit* q);
    VariationalQuantumGate_S(const VariationalQuantumGate_S& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_S dagger();
    VariationalQuantumGate_S control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_SWAP

Overview

#include <var.h>

class VariationalQuantumGate_SWAP: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_SWAP(
        Qubit* q1,
        Qubit* q2
        );

    VariationalQuantumGate_SWAP(const VariationalQuantumGate_SWAP& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_SWAP dagger();
    VariationalQuantumGate_SWAP control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_SqiSWAP

Overview

#include <var.h>

class VariationalQuantumGate_SqiSWAP: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_SqiSWAP(
        Qubit* q1,
        Qubit* q2
        );

    VariationalQuantumGate_SqiSWAP(const VariationalQuantumGate_SqiSWAP& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_SqiSWAP dagger();
    VariationalQuantumGate_SqiSWAP control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_T

Overview

#include <var.h>

class VariationalQuantumGate_T: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_T(Qubit* q);
    VariationalQuantumGate_T(const VariationalQuantumGate_T& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_T dagger();
    VariationalQuantumGate_T control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_U1

Overview

#include <var.h>

class VariationalQuantumGate_U1: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_U1(
        Qubit*,
        var
        );

    VariationalQuantumGate_U1(
        Qubit*,
        double angle
        );

    VariationalQuantumGate_U1(const VariationalQuantumGate_U1& gate);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_U1 dagger();
    VariationalQuantumGate_U1 control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_U2

Overview

#include <var.h>

class VariationalQuantumGate_U2: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_U2(
        Qubit*,
        var,
        var
        );

    VariationalQuantumGate_U2(
        Qubit*,
        double,
        double
        );

    VariationalQuantumGate_U2(const VariationalQuantumGate_U2& gate);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_U2 dagger();
    VariationalQuantumGate_U2 control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_U3

Overview

#include <var.h>

class VariationalQuantumGate_U3: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_U3(
        Qubit*,
        var,
        var,
        var
        );

    VariationalQuantumGate_U3(
        Qubit*,
        double,
        double,
        double
        );

    VariationalQuantumGate_U3(const VariationalQuantumGate_U3& gate);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_U3 dagger();
    VariationalQuantumGate_U3 control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_U4

Overview

#include <var.h>

class VariationalQuantumGate_U4: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_U4(
        Qubit*,
        var,
        var,
        var,
        var
        );

    VariationalQuantumGate_U4(
        Qubit*,
        double,
        double,
        double,
        double
        );

    VariationalQuantumGate_U4(const VariationalQuantumGate_U4& gate);

    // methods

    virtual QGate feed();
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_U4 dagger();
    VariationalQuantumGate_U4 control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual QGate feed(std::map<size_t, double> offset)

Interface to instantialize the QGate with the “offset”.

Parameters:

offset

<number of variable, offset>

Returns:

QGate

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_X

Overview

#include <var.h>

class VariationalQuantumGate_X: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_X(Qubit* q);
    VariationalQuantumGate_X(const VariationalQuantumGate_X& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_X dagger();
    VariationalQuantumGate_X control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_X1

Overview

#include <var.h>

class VariationalQuantumGate_X1: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_X1(Qubit* q);
    VariationalQuantumGate_X1(const VariationalQuantumGate_X1& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_X1 dagger();
    VariationalQuantumGate_X1 control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_Y

Overview

#include <var.h>

class VariationalQuantumGate_Y: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_Y(Qubit* q);
    VariationalQuantumGate_Y(const VariationalQuantumGate_Y& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_Y dagger();
    VariationalQuantumGate_Y control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_Y1

Overview

#include <var.h>

class VariationalQuantumGate_Y1: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_Y1(Qubit* q);
    VariationalQuantumGate_Y1(const VariationalQuantumGate_Y1& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_Y1 dagger();
    VariationalQuantumGate_Y1 control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_Z

Overview

#include <var.h>

class VariationalQuantumGate_Z: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_Z(Qubit* q);
    VariationalQuantumGate_Z(const VariationalQuantumGate_Z& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_Z dagger();
    VariationalQuantumGate_Z control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_Z1

Overview

#include <var.h>

class VariationalQuantumGate_Z1: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_Z1(Qubit* q);
    VariationalQuantumGate_Z1(const VariationalQuantumGate_Z1& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_Z1 dagger();
    VariationalQuantumGate_Z1 control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::VariationalQuantumGate_iSWAP

Overview

#include <var.h>

class VariationalQuantumGate_iSWAP: public QPanda::Variational::VariationalQuantumGate
{
public:
    // construction

    VariationalQuantumGate_iSWAP(
        Qubit* q1,
        Qubit* q2
        );

    VariationalQuantumGate_iSWAP(const VariationalQuantumGate_iSWAP& gate);

    // methods

    virtual QGate feed();
    virtual std::shared_ptr<VariationalQuantumGate> copy();
    VariationalQuantumGate_iSWAP dagger();
    VariationalQuantumGate_iSWAP control(QVec qv);
};

Inherited Members

public:
    // methods

    size_t n_var();
    const std::vector<var>& get_vars();
    const std::vector<double>& get_constants();
    int var_pos(var _var);
    virtual QGate feed() = 0;
    virtual QGate feed(std::map<size_t, double> offset);
    virtual std::shared_ptr<VariationalQuantumGate> copy() = 0;
    virtual bool set_dagger(bool dagger);
    virtual bool set_control(QVec control_qubit);
    virtual bool is_dagger();
    virtual QVec get_control_qubit();
    virtual void copy_dagger_and_control_qubit(QGate& gate);
    virtual void copy_dagger_and_control_qubit(std::shared_ptr<VariationalQuantumGate> gate);

Detailed Documentation

Methods

virtual QGate feed()

Interface to instantialize the QGate with VQG.

Returns:

QGate Instantiation

virtual std::shared_ptr<VariationalQuantumGate> copy()

Interface to copy the instance, and return a shared_ptr for the object.

Returns:

std::shared_ptr<VariationalQuantumGate>

class QPanda::Variational::var

Overview

The class denotes the variable. More…

#include <var.h>

class var
{
public:
    // fields

    std::shared_ptr<impl> pimpl;

    // construction

    var(std::shared_ptr<impl>);
    var(double);
    var(const MatrixXd&);

    var(
        double,
        bool
        );

    var(
        const MatrixXd&,
        bool
        );

    var(op_type op, const std::vector<var>& children);
    var(var&&);
    var(const var&);

    // methods

    var& operator = (var&&);
    var& operator = (const var&);
    var clone();
    virtual size_t getNumOpArgs();
    MatrixXd getValue() const;
    void setValue(const MatrixXd&);
    op_type getOp() const;
    void setOp(op_type);
    std::vector<var>& getChildren() const;
    std::vector<var> getParents() const;
    long getUseCount() const;
    bool getValueType() const;
    MatrixXd _eval();

    MatrixXd _back_single(
        const MatrixXd& dx,
        size_t op_idx
        );

    std::vector<MatrixXd> _back(
        const MatrixXd& dx,
        const std::unordered_set<var>& nonconsts
        );

    std::vector<MatrixXd> _back(const MatrixXd& dx);
    bool operator == (const var& rhs) const;
    const var operator [] (int subscript);
};

Detailed Documentation

The class denotes the variable.

Construction

var(std::shared_ptr<impl>)

Construct a new var object by the impl object.

var(double)

Construct a new var object by a double.

var(const MatrixXd&)

Construct a new var object by a Eigen matrix.

var(op_type op, const std::vector<var>& children)

Construct a new var object by the operator type and children.

Parameters:

op	operator type
children	children of the operator. For example, c = a + b. c is a and b’s parent, a and b are c’s children

var(var&&)

move constructor of var

Methods

var& operator = (var&&)

Returns:

var&

namespace Variational {

// typedefs

typedef VariationalQuantumGate_H VQG_H;
typedef VariationalQuantumGate_X VQG_X;
typedef VariationalQuantumGate_X1 VQG_X1;
typedef VariationalQuantumGate_Y VQG_Y;
typedef VariationalQuantumGate_Y1 VQG_Y1;
typedef VariationalQuantumGate_Z VQG_Z;
typedef VariationalQuantumGate_Z1 VQG_Z1;
typedef VariationalQuantumGate_S VQG_S;
typedef VariationalQuantumGate_T VQG_T;
typedef VariationalQuantumGate_U1 VQG_U1;
typedef VariationalQuantumGate_RX VQG_RX;
typedef VariationalQuantumGate_RY VQG_RY;
typedef VariationalQuantumGate_RZ VQG_RZ;
typedef VariationalQuantumGate_U2 VQG_U2;
typedef VariationalQuantumGate_RPhi VQG_RPhi;
typedef VariationalQuantumGate_U3 VQG_U3;
typedef VariationalQuantumGate_U4 VQG_U4;
typedef VariationalQuantumGate_CNOT VQG_CNOT;
typedef VariationalQuantumGate_CZ VQG_CZ;
typedef VariationalQuantumGate_SWAP VQG_SWAP;
typedef VariationalQuantumGate_iSWAP VQG_iSWAP;
typedef VariationalQuantumGate_SqiSWAP VQG_SqiSWAP;
typedef VariationalQuantumGate_CR VQG_CR;
typedef VariationalQuantumGate_CU VQG_CU;
typedef VariationalQuantumGate_CRX VQG_CRX;
typedef VariationalQuantumGate_CRY VQG_CRY;
typedef VariationalQuantumGate_CRZ VQG_CRZ;
typedef VariationalQuantumGate VQG;
typedef VariationalQuantumCircuit VQC;

// enums

enum OptimizerMode;
enum back_flags;
enum op_type;

// structs

struct impl;
struct impl_qop_pmeasure;
struct impl_qop_pmeasure_real_chip;
struct impl_stack;
struct impl_subscript;
struct impl_vqp;
struct impl_vqp_real_chip;

// classes

class AdaGradOptimizer;
class AdamOptimizer;
class Double;
class MomentumOptimizer;
class Optimizer;
class RMSPropOptimizer;
class VanillaGradientDescentOptimizer;
class VariationalQuantumCircuit;
class VariationalQuantumGate;
class VariationalQuantumGate_CNOT;
class VariationalQuantumGate_CR;
class VariationalQuantumGate_CRX;
class VariationalQuantumGate_CRY;
class VariationalQuantumGate_CRZ;
class VariationalQuantumGate_CU;
class VariationalQuantumGate_CZ;
class VariationalQuantumGate_H;
class VariationalQuantumGate_RPhi;
class VariationalQuantumGate_RX;
class VariationalQuantumGate_RY;
class VariationalQuantumGate_RZ;
class VariationalQuantumGate_S;
class VariationalQuantumGate_SWAP;
class VariationalQuantumGate_SqiSWAP;
class VariationalQuantumGate_T;
class VariationalQuantumGate_U1;
class VariationalQuantumGate_U2;
class VariationalQuantumGate_U3;
class VariationalQuantumGate_U4;
class VariationalQuantumGate_X;
class VariationalQuantumGate_X1;
class VariationalQuantumGate_Y;
class VariationalQuantumGate_Y1;
class VariationalQuantumGate_Z;
class VariationalQuantumGate_Z1;
class VariationalQuantumGate_iSWAP;
class expression;
class var;

// global functions

MatrixXd eval(
    var v,
    bool iter
    );

void back(
    const var&,
    std::unordered_map<var, MatrixXd>&
    );

void back(
    expression&,
    std::unordered_map<var, MatrixXd>&
    );

void back(
    const var&,
    std::unordered_map<var, MatrixXd>&,
    const std::unordered_set<var>&
    );

void back(
    expression&,
    std::unordered_map<var, MatrixXd>&,
    const std::unordered_set<var>&
    );

int numOpArgs(op_type op);
VariationalQuantumCircuit& VariationalQuantumCircuit::insert< std::shared_ptr< VariationalQuantumGate > >(std::shared_ptr<VariationalQuantumGate> gate);

template <typename... V>
const var pack_expression(
    op_type op,
    V&... args
    );

template <typename... V>
const var pack_expression(
    op_type op,
    int axis,
    V&... args
    );

const var operator + (
    var lhs,
    var rhs
    );

const var operator - (
    var lhs,
    var rhs
    );

const var operator * (
    var lhs,
    var rhs
    );

const var operator/ (
    var lhs,
    var rhs
    );

const var exp(var v);
const var sigmoid(var v);
const var log(var v);

const var poly(
    var v,
    var power
    );

const var dot(
    var lhs,
    var rhs
    );

const var inverse(var v);
const var transpose(var v);
const var sum(var v);
const var softmax(var v);

const var crossEntropy(
    var lhs,
    var rhs
    );

const var dropout(
    var lhs,
    var rhs
    );

template <typename ... T>
const var stack(
    int axis,
    T&... v
    );

const var qop(
    VariationalQuantumCircuit& circuit,
    PauliOperator Hamiltonian,
    QuantumMachine* machine,
    std::vector<Qubit*> measure_qubits
    );

const var qop_real_chip(
    VariationalQuantumCircuit& circuit,
    PauliOperator Hamiltonian,
    QuantumMachine* machine,
    std::vector<Qubit*> measure_qubits,
    int shots
    );

const var qop(
    VariationalQuantumCircuit& circuit,
    PauliOperator Hamiltonian,
    QuantumMachine* machine,
    std::map<size_t, Qubit*> measure_qubits
    );

const var qop_pmeasure(
    VariationalQuantumCircuit& circuit,
    std::vector<size_t> components,
    QuantumMachine* machine,
    std::vector<Qubit*> measure_qubits
    );

const var qop_pmeasure_real_chip(
    VariationalQuantumCircuit& circuit,
    std::vector<size_t> components,
    QuantumMachine* machine,
    std::vector<Qubit*> measure_qubits,
    std::vector<ClassicalCondition> cbits,
    size_t shots
    );

bool _is_scalar(const var& v);
bool _is_matrix(const var& v);
bool _is_vector(const var& v);
double _sval(const var& v);
MatrixXd _mval(const var& v);
MatrixXd scalar(double num);
MatrixXd vector2mat(std::vector<double> data);
MatrixXd zeros_like(const MatrixXd& like);
MatrixXd zeros_like(const var& like);
MatrixXd ones_like(const MatrixXd& like);
MatrixXd ones_like(const var& like);

} // namespace Variational

enum QPanda::ArchType

#include <TopologyMatch.h>

enum ArchType
{
    IBM_QX5_ARCH        = 0,
    ORIGIN_VIRTUAL_ARCH,
};

enum QPanda::CLOUD_QMACHINE_TYPE

#include <QCloudMachine.h>

enum CLOUD_QMACHINE_TYPE
{
    Full_AMPLITUDE,
    NOISE_QMACHINE,
    PARTIAL_AMPLITUDE,
    SINGLE_AMPLITUDE,
    CHEMISTRY,
    REAL_CHIP,
    QST,
    FIDELITY,
};

enum QPanda::ComplexVertexSplitMethod

#include <GetQubitTopology.h>

enum ComplexVertexSplitMethod
{
    METHOD_UNDEFINED = -1,
    LINEAR           = 0,
    RING,
};

enum QPanda::ContentSpecifier

Overview

Content specifier. More…

#include <ClassicalConditionInterface.h>

enum ContentSpecifier
{
    CBIT,
    OPERATOR,
    CONSTVALUE,
};

Detailed Documentation

Content specifier.

Enum Values

CBIT

cbit type

OPERATOR

operator type

CONSTVALUE

const value type

enum QPanda::DAGNodeType

#include <QProgDAG.h>

enum DAGNodeType
{
    NUKNOW_SEQ_NODE_TYPE = -1,
    MAX_GATE_TYPE        = 0XF0,
    MEASURE              = 0XF1,
    RESET,
};

enum QPanda::DecompositionMode

#include <MatrixDecomposition.h>

enum DecompositionMode
{
    QR             = 0,
    HOUSEHOLDER_QR,
};

enum QPanda::DoubleGateTransferType

Double gate transfer type.

#include <MetadataValidity.h>

enum DoubleGateTransferType
{
    DOUBLE_GATE_INVALID = -1,
    DOUBLE_BIT_GATE,
};

enum QPanda::KarusErrorType

#include <NoiseSimulator.h>

enum KarusErrorType
{
    KARUS_MATRIICES,
    UNITARY_MATRIICES,
};

enum QPanda::MatrixUnit

#include <MatrixDecomposition.h>

enum MatrixUnit
{
    SINGLE_P0,
    SINGLE_P1,
    SINGLE_I2,
    SINGLE_V2,
};

enum QPanda::MeasBasis

#include <CutQC.h>

enum MeasBasis
{
    BASIS_Z,
    BASIS_X,
    BASIS_Y,
};

enum QPanda::MeasState

#include <CutQC.h>

enum MeasState
{
    Zp,
    Zm,
    Xp,
    Xm,
    Yp,
    Ym,
};

enum QPanda::MeasureQVMType

Overview

#include <CrossEntropyBenchmarking.h>

enum MeasureQVMType
{
    NOISE,
    WU_YUAN,
};

Detailed Documentation

Enum Values

NOISE

Cpu quantum machine with noise

WU_YUAN

Wu Yuan real chip

enum QPanda::OperatorSpecifier

Overview

Operator specifier. More…

#include <ClassicalConditionInterface.h>

enum OperatorSpecifier
{
    PLUS,
    MINUS,
    MUL,
    DIV,
    GT,
    EGT,
    LT,
    ELT,
    EQUAL,
    NE,
    AND,
    OR,
    NOT,
    ASSIGN,
};

Detailed Documentation

Operator specifier.

Enum Values

PLUS

Add operator type.

MINUS

Minus operator type.

MUL

Multiply operation type.

DIV

Division operation type.

GT

Greater than operation type.

EGT

Greater than or equal to operation type.

LT

Less than operation type.

ELT

Less than or equal to operation type.

EQUAL

Equal operator type.

NE

Not equal to operation type.

AND

And operation type.

OR

OR operation type.

NOT

NOT operation type.

ASSIGN

ASSIGN operation type.

enum QPanda::PrepState

#include <CutQC.h>

enum PrepState
{
    S0,
    S1,
    S2,
    S3,
};

enum QPanda::QASMGateType

QASM quantum gate type.

#include <QASMToQProg.h>

enum QASMGateType
{
    ID_GATE      =0,
    X_GATE,
    Y_GATE,
    Z_GATE,
    H_GATE,
    S_GATE,
    SDG_GATE,
    T_GATE,
    TDG_GATE,
    RX_GATE,
    RY_GATE,
    RZ_GATE,
    CX_GATE,
    CZ_GATE,
    CY_GATE,
    CH_GATE,
    U3_GATE,
    U2_GATE,
    U1_GATE,
    CCX_GATE,
    CRZ_GATE,
    CU1_GATE,
    CU3_GATE,
    U_BASE_GATE,
    CX_BASE_GATE,
};

enum QPanda::QCircuitOPtimizerMode

#include <QCircuitOptimize.h>

enum QCircuitOPtimizerMode
{
    Undefine_mode = -1,
    Merge_H_X     = 1,
    Merge_U3      =(1<<1),
    Merge_RX      =(1<<2),
    Merge_RY      =(1<<3),
    Merge_RZ      =(1<<4),
};

enum QPanda::QCodarGridDevice

QCodar Grid Device type.

#include <QCodarMatch.h>

enum QCodarGridDevice
{
    IBM_Q20_TOKYO  = 0,
    IBM_Q53,
    GOOGLE_Q54,
    SIMPLE_TYPE,
    ORIGIN_VIRTUAL,
};

enum QPanda::QMachineType

Overview

#include <QuantumMachineInterface.h>

enum QMachineType
{
    CPU,
    GPU,
    CPU_SINGLE_THREAD,
    NOISE,
};

Detailed Documentation

Enum Values

CPU

Cpu quantum machine

GPU

Gpu quantum machine

CPU_SINGLE_THREAD

Cpu quantum machine with single thread

NOISE

Cpu quantum machine with noise

enum QPanda::QProgStoredNodeType

Quantum Program Stored Node Type.

#include <QProgStored.h>

enum QProgStoredNodeType
{
    QPROG_PAULI_X_GATE     = 1u,
    QPROG_PAULI_Y_GATE,
    QPROG_PAULI_Z_GATE,
    QPROG_X_HALF_PI,
    QPROG_Y_HALF_PI,
    QPROG_Z_HALF_PI,
    QPROG_HADAMARD_GATE,
    QPROG_T_GATE,
    QPROG_S_GATE,
    QPROG_RX_GATE,
    QPROG_RY_GATE,
    QPROG_RZ_GATE,
    QPROG_U1_GATE,
    QPROG_U2_GATE,
    QPROG_U3_GATE,
    QPROG_U4_GATE,
    QPROG_CU_GATE,
    QPROG_CNOT_GATE,
    QPROG_CZ_GATE,
    QPROG_CPHASE_GATE,
    QPROG_ISWAP_GATE,
    QPROG_ISWAP_THETA_GATE,
    QPROG_SQISWAP_GATE,
    QPROG_SWAP_GATE,
    QPROG_GATE_ANGLE,
    QPROG_MEASURE_GATE,
    QPROG_QIF_NODE,
    QPROG_QWHILE_NODE,
    QPROG_CEXPR_CBIT,
    QPROG_CEXPR_OPERATOR,
    QPROG_CEXPR_CONSTVALUE,
    QPROG_CEXPR_EVAL,
    QPROG_CEXPR_NODE,
    QPROG_CONTROL,
    QPROG_CIRCUIT_NODE,
    QPROG_RESET_NODE,
    QPROG_I_GATE,
};

enum QPanda::REAL_CHIP_TYPE

#include <QCloudMachine.h>

enum REAL_CHIP_TYPE
{
    UDEFINED,
    ORIGIN_WUYUAN,
};

enum QPanda::SingleGateTransferType

Single gate transfer type.

#include <MetadataValidity.h>

enum SingleGateTransferType
{
    SINGLE_GATE_INVALID        = -1,
    ARBITRARY_ROTATION,
    DOUBLE_CONTINUOUS,
    SINGLE_CONTINUOUS_DISCRETE,
    DOUBLE_DISCRETE,
};

enum QPanda::SwapQubitsMethod

#include <TopologyMatch.h>

enum SwapQubitsMethod
{
    ISWAP_GATE_METHOD = 0,
    CZ_GATE_METHOD,
    CNOT_GATE_METHOD,
    SWAP_GATE_METHOD,
};

template struct QPanda::CNodeCandidate

Composition of each candidate in phase 1.

#include <OBMTQMapping.h>

template <typename T>
struct CNodeCandidate
{
    // fields

    Dep dep;
    T cNode;
    uint32_t weight;

    // methods

    bool operator > (const CNodeCandidate& rhs) const;
};

struct QPanda::CandidateSelector

Overview

Interface for selecting candidates (if they are greater than a max) in phase 1. More…

#include <OBMTQMapping.h>

struct CandidateSelector
{
    // typedefs

    typedef CandidateSelector* Ref;
    typedef std::unique_ptr<CandidateSelector> uRef;

    // methods

    virtual std::vector<MappingCandidate> select(uint32_t maxCandidates, const std::vector<MappingCandidate>& candidates) = 0;
};

Detailed Documentation

Interface for selecting candidates (if they are greater than a max) in phase 1.

Methods

virtual std::vector<MappingCandidate> select(
    uint32_t maxCandidates,
    const std::vector<MappingCandidate>& candidates
    ) = 0

Selects maxCandidates from candidates.

struct QPanda::DAGSeqNode

Overview

#include <QProgDAG.h>

struct DAGSeqNode
{
    // fields

    int m_node_type;
    size_t m_vertex_num;

    // construction

    DAGSeqNode();
    DAGSeqNode(const QProgDAGVertex& dag_vertex);

    // methods

    bool operator == (const DAGSeqNode& node) const;
    bool operator < (const DAGSeqNode& node) const;
    bool operator > (const DAGSeqNode& node) const;
};

Detailed Documentation

Construction

DAGSeqNode()

construct sequence node

Parameters:

size_t

vertex num

Returns:

QPanda::SequenceNode

struct QPanda::DefineQGateContent

#include <OriginIRToQProg.h>

struct DefineQGateContent
{
    // fields

    std::string define_name;
    std::vector<std::string> formal_qubits;
    std::vector<std::string> formal_angles;
    std::vector<CallGateInfo> gate_bodys;
};

struct QPanda::Dep

Structure for abstracting dependencies.

#include <OBMTQMapping.h>

struct Dep
{
    // fields

    uint32_t mFrom;
    uint32_t mTo;
};

struct QPanda::Dependencies

Overview

Represents a sequence of dependencies (should be treated as parallel dependencies) for each node. More…

#include <OBMTQMapping.h>

struct Dependencies
{
    // typedefs

    typedef std::vector<Dep>::iterator Iterator;
    typedef std::vector<Dep>::const_iterator ConstIterator;

    // fields

    std::vector<Dep> mDeps;
    QNodeRef mCallPoint;

    // methods

    const Dep& operator [] (uint32_t i) const;
    Dep& operator [] (uint32_t i);
    bool empty() const;
    uint32_t size() const;
    Iterator begin();
    ConstIterator begin() const;
    Iterator end();
    ConstIterator end() const;
};

Detailed Documentation

Represents a sequence of dependencies (should be treated as parallel dependencies) for each node.

Methods

const Dep& operator [] (uint32_t i) const

Forwards to the mDeps attribute.

Dep& operator [] (uint32_t i)

Forwards to the mDeps attribute.

bool empty() const

Forwards to the mDeps attribute.

uint32_t size() const

Forwards to the mDeps attribute.

Iterator begin()

Forwards to the mDeps attribute.

ConstIterator begin() const

Forwards to the mDeps attribute.

Iterator end()

Forwards to the mDeps attribute.

ConstIterator end() const

Forwards to the mDeps attribute.

struct QPanda::Dist

Dijkstra graph node.

#include <GraphDijkstra.h>

struct Dist
{
    // fields

    std::vector<int> path_vec;
    int value;
    bool visit;
};

struct QPanda::FragLabel

#include <CutQC.h>

struct FragLabel
{
    // fields

    std::string m_prep_label;
    std::string m_meas_label;
};

struct QPanda::GataFuncInfo

#include <QASMToQProg.h>

struct GataFuncInfo
{
    // fields

    std::string func_name;
    std::vector<std::string> angle_names_vec;
    std::vector<std::string> reg_names_vec;
    std::vector<GateOperationInfo> ops_vec;
};

struct QPanda::GateInfo

Save the parsed logical gate information.

#include <QScheduler.h>

struct GateInfo
{
    // fields

    int target;
    int control;
    int type;
    bool is_dagger;
    std::vector<double> param;
    std::string gate_name;
    int barrier_id;
};

struct QPanda::GateOperationInfo

#include <QASMToQProg.h>

struct GateOperationInfo
{
    // fields

    std::string op_id;
    std::vector<RegParamInfo> regs_vec;
    std::vector<std::shared_ptr<Exp>> angles_vec;
};

template struct QPanda::JsonBackendParser<ArchGraph>

#include <ArchGraph.h>

template <>
struct JsonBackendParser<ArchGraph>
{
    // methods

    static std::unique_ptr<ArchGraph> Parse(const rapidjson::Value& root);
};

template struct QPanda::JsonBackendParser

#include <Graph.h>

template <class T>
struct JsonBackendParser
{
    // methods

    static std::unique_ptr<T> Parse(const rapidjson::Value& root);
    int32_t ParseWeight(const rapidjson::Value& v);
    uint32_t ParseWeight(const rapidjson::Value& v);
    double ParseWeight(const rapidjson::Value& v);
};

template struct QPanda::JsonBackendParser<WeightedGraph<T>>

#include <Graph.h>

template <class T>
struct JsonBackendParser<WeightedGraph<T>>
{
    // methods

    static T ParseWeight(const rapidjson::Value& v);
    static std::unique_ptr<WeightedGraph<T>> Parse(const rapidjson::Value& root);
};

template struct QPanda::JsonBackendParser<Graph>

#include <Graph.h>

template <>
struct JsonBackendParser<Graph>
{
    // methods

    static std::unique_ptr<Graph> Parse(const rapidjson::Value& root);
};

template struct QPanda::JsonFields<ArchGraph>

#include <ArchGraph.h>

template <>
struct JsonFields<ArchGraph>
{
    // fields

    static const std::string _quantum_chip_arch_label;
    static const std::string _qubits_label;
    static const std::string _name_label;
    static const std::string _adj_list_label;
    static const std::string _v_label;
    static const std::string _weight_label;
};

template struct QPanda::JsonFields<WeightedGraph<T>>

#include <Graph.h>

template <class T>
struct JsonFields<WeightedGraph<T>>
{
    // fields

    static std::string _WeightLabel_ = "w";
};

template struct QPanda::JsonFields<Graph>

#include <Graph.h>

template <>
struct JsonFields<Graph>
{
    // fields

    static const std::string _VerticesLabel_;
    static const std::string _AdjListLabel_;
    static const std::string _TypeLabel_;
    static const std::string _VLabel_;
};

template struct QPanda::JsonFields

struct QPanda::MappingCandidate

Composition of each candidate in phase 1.

#include <OBMTQMapping.h>

struct MappingCandidate
{
    // fields

    Mapping m;
    uint32_t cost;
    double reliability = 1.0;
    uint32_t weight;

    // methods

    bool operator > (const MappingCandidate& rhs) const;
};

struct QPanda::MappingSeq

Keep track of the sequence of Mapping s and its cost.

#include <OBMTQMapping.h>

struct MappingSeq
{
    // fields

    MappingVector mappingV;
    uint32_t mappingCost;
};

struct QPanda::MappingSwapSequence

Holds the sequence of Mapping s and Swaps to be executed.

#include <OBMTQMapping.h>

struct MappingSwapSequence
{
    // fields

    std::vector<Mapping> mappings;
    std::vector<SwapSeq> swapSeqs;
    uint32_t cost;
    double reliability;
};

struct QPanda::NoiseConfigs

#include <QCloudMachine.h>

struct NoiseConfigs
{
    // fields

    std::string noise_model;
    double single_gate_param;
    double double_gate_param;
    double single_p2;
    double double_p2;
    double single_pgate;
    double double_pgate;
};

struct QPanda::OptimizerNodeInfo

Overview

#include <ProcessOnTraversing.h>

struct OptimizerNodeInfo: public QPanda::NodeInfo
{
    // fields

    size_t m_layer;
    int m_type;
    std::shared_ptr<QNode> m_parent_node;
    int m_sub_graph_index;

    // construction

    OptimizerNodeInfo(
        const NodeIter iter,
        size_t layer,
        QVec target_qubits,
        QVec control_qubits,
        int type,
        std::shared_ptr<QNode> parent_node,
        const bool dagger
        );

    // methods

    virtual void reset();
    void insert_QNode(std::shared_ptr<QNode> node);
    bool operator == (const OptimizerNodeInfo& other) const;
    bool is_empty() const;
};

Inherited Members

public:
    // fields

    NodeIter m_iter;
    NodeType m_node_type;
    GateType m_gate_type;
    bool m_is_dagger;
    QVec m_target_qubits;
    QVec m_control_qubits;
    std::vector<int> m_cbits;
    std::vector<double> m_params;
    std::string m_name;

    // methods

    virtual void reset();

Detailed Documentation

Methods

virtual void reset()

reset the node information

struct QPanda::OptimizerSubCir

#include <QCircuitOptimize.h>

struct OptimizerSubCir
{
    // fields

    QCircuit target_sub_cir;
    QCircuit replace_to_sub_cir;
};

struct QPanda::PressedCirNode

#include <ProcessOnTraversing.h>

struct PressedCirNode
{
    // fields

    pOptimizerNodeInfo m_cur_node;
    std::vector<pOptimizerNodeInfo> m_relation_pre_nodes;
    std::vector<pOptimizerNodeInfo> m_relation_successor_nodes;
};

struct QPanda::QCircuitConfig

#include <MPSImplQPU.h>

struct QCircuitConfig
{
    // fields

    bool _is_dagger = false;
    QVec _contorls;
    bool _can_optimize_measure = true;
};

struct QPanda::QCircuitConfigReader

#include <JsonConfigParam.h>

struct QCircuitConfigReader
{
    // fields

    const rapidjson::Value& m_circuit_config;
    QCircuitGenerator& m_cir_generator;

    // construction

    QCircuitConfigReader(
        const rapidjson::Value& circuit_config,
        QCircuitGenerator& cir_generator
        );

    // methods

    void read_cir();
};

struct QPanda::QGateNode

#include <PartialAmplitudeGraph.h>

struct QGateNode
{
    // fields

    unsigned short gate_type;
    bool isConjugate;
    uint32_t tar_qubit;
    uint32_t ctr_qubit;
    float gate_parm;
    uint32_t tof_qubit;
};

struct QPanda::QGatesTransform

#include <TransformDecomposition.h>

struct QGatesTransform
{
    // fields

    axis n1;
    axis n2;
};

struct QPanda::QProgDAGEdge

#include <QProgDAG.h>

struct QProgDAGEdge
{
    // fields

    uint32_t m_from;
    uint32_t m_to;
    uint32_t m_qubit;

    // construction

    QProgDAGEdge(
        uint32_t from,
        uint32_t to,
        uint32_t qubit
        );

    // methods

    bool operator < (const QProgDAGEdge& e) const;
    bool operator == (const QProgDAGEdge& e) const;
};

struct QPanda::QProgDAGNode

#include <QProgDAG.h>

struct QProgDAGNode
{
    // fields

    NodeIter m_itr;
    bool m_dagger;
    QVec m_qubits_vec;
    QVec m_control_vec;
    std::vector<double> m_angles;

    // methods

    void copy(std::shared_ptr<QProgDAGNode> node);
};

struct QPanda::QubitPointerCmp

#include <QProgFlattening.h>

struct QubitPointerCmp
{
    // methods

    bool operator () (
        Qubit* left,
        Qubit* right
        ) const;
};

struct QPanda::RegParamInfo

#include <QASMToQProg.h>

struct RegParamInfo
{
    // fields

    std::string reg_name;
    int reg_index;
};

struct QPanda::StitchesInfo

Overview

Cutting point information Note: Each cut point corresponds to a measurement-qubit and a preparation-qubit of two sub-circuit respectively. More…

#include <CutQC.h>

struct StitchesInfo
{
    // typedefs

    typedef std::pair<uint32_t, uint32_t> sub_cir_op_qubit_index;

    // fields

    sub_cir_op_qubit_index m_meas_qubit;
    sub_cir_op_qubit_index m_prep_qubit;
};

Detailed Documentation

Cutting point information Note: Each cut point corresponds to a measurement-qubit and a preparation-qubit of two sub-circuit respectively.

Typedefs

typedef std::pair<uint32_t, uint32_t> sub_cir_op_qubit_index

sub_circuit_index : qubit_index

struct QPanda::SubCircuit

#include <CutQC.h>

struct SubCircuit
{
    // fields

    QCircuit m_cir;
    QVec m_prep_qubit;
    QVec m_meas_qubit;
};

struct QPanda::Swap

#include <QubitMapping.h>

struct Swap
{
    // fields

    uint32_t u;
    uint32_t v;
};

struct QPanda::TracebackInfo

Necessary information for getting the combinations in phase 2.

#include <OBMTQMapping.h>

struct TracebackInfo
{
    // fields

    Mapping m;
    uint32_t parent;
    uint32_t mappingCost;
    uint32_t swapEstimatedCost;
    double mappingReliability;
    double swapEstimatedReliability;
};

struct QPanda::_blocked_matrix

#include <QStatMatrix.h>

struct _blocked_matrix
{
    // fields

    int m_block_rows;
    int m_block_columns;
    std::vector<matrixBlock_t> m_vec_block;
};

struct QPanda::_matrix_block

#include <QStatMatrix.h>

struct _matrix_block
{
    // fields

    int m_row_index;
    int m_column_index;
    qmatrix_t m_mat;
};

struct QPanda::axis

#include <TransformDecomposition.h>

struct axis
{
    // fields

    double nx;
    double ny;
    double nz;
};

class QPanda::AbstractCirOptimizer

#include <QCircuitOptimize.h>

class AbstractCirOptimizer
{
public:
    // methods

    virtual void do_optimize(
        QProg src_prog,
        OptimizerSink& gates_sink,
        SinkPos& sink_size,
        std::vector<QCircuit>& replace_to_cir_vec
        ) = 0;

    virtual bool is_same_controled(
        pOptimizerNodeInfo first_node,
        pOptimizerNodeInfo second_node
        );
};

class QPanda::AbstractDiffusionOperator

#include <DiffusionCircuit.h>

class AbstractDiffusionOperator
{
public:
    // methods

    virtual QCircuit build_diffusion_circuit(const QVec& qvec) = 0;
};

// direct descendants

class DiffusionCirBuilder;

class QPanda::AbstractQuantumCounting

#include <QuantumCounting.h>

class AbstractQuantumCounting
{
public:
    // methods

    virtual size_t qu_counting() = 0;
};

// direct descendants

class QuantumCounting;

class QPanda::AbstractQubitMapping

Base abstract class that allocates the qbits used in the program to the qbits that are in the physical architecture.

#include <QubitMapping.h>

class AbstractQubitMapping
{
public:
    // typedefs

    typedef AbstractQubitMapping* Ref;
    typedef std::unique_ptr<AbstractQubitMapping> uRef;

    // methods

    bool run(
        QPanda::QProg prog,
        QPanda::QuantumMachine* qvm
        );

    void setGateWeightMap(const GateWeightMap& weightMap);
    const Mapping& get_final_mapping() const;
    const Mapping& get_init_mapping() const;
    QPanda::QProg get_mapped_prog() const;
};

// direct descendants

class OptBMTQAllocator;
class SabreQAllocator;

class QPanda::AbstractSearchData

#include <SearchDataType.h>

class AbstractSearchData
{
public:
    // methods

    virtual bool operator < (const AbstractSearchData& other) const = 0;
    virtual bool operator <= (const AbstractSearchData& other) const = 0;
    virtual bool operator > (const AbstractSearchData& other) const = 0;
    virtual bool operator >= (const AbstractSearchData& other) const = 0;
    virtual bool operator == (const AbstractSearchData&& other) const = 0;
    virtual AbstractSearchData& operator - (const AbstractSearchData& other) = 0;

    virtual QCircuit build_to_circuit(
        QVec& used_qubits,
        size_t use_qubit_cnt,
        const AbstractSearchData& mini_data
        ) const = 0;

    virtual QCircuit build_to_condition_circuit(
        QVec& used_qubits,
        QCircuit cir_mark,
        const AbstractSearchData& mini_data
        ) = 0;

    virtual size_t check_max_need_qubits() = 0;
    virtual AbstractSearchData& set_val(const char* p_val) = 0;
};

// direct descendants

class SearchDataByUInt;

class QPanda::ApproxTSFinder

4-Approximative polynomial algorithm. Miltzow et al. DOI: 10.4230/LIPIcs.ESA.2016.66

#include <TokenSwapFinder.h>

class ApproxTSFinder: public QPanda::TokenSwapFinder
{
public:
    // typedefs

    typedef ApproxTSFinder* Ref;
    typedef std::unique_ptr<ApproxTSFinder> uRef;

    // methods

    static uRef Create();
};

Inherited Members

public:
    // typedefs

    typedef TokenSwapFinder* Ref;
    typedef std::unique_ptr<TokenSwapFinder> uRef;

    // methods

    void set_graph(QPanda::Graph::Ref graph);
    SwapSeq find(const InverseMap& from, const InverseMap& to);

class QPanda::ArchGraph

Overview

This is the base class for the architectures that this project will be supporting. More…

#include <ArchGraph.h>

class ArchGraph: public QPanda::WeightedGraph
{
public:
    // typedefs

    typedef ArchGraph* Ref;
    typedef std::unique_ptr<ArchGraph> uRef;
    typedef std::shared_ptr<ArchGraph> sRef;
    typedef std::vector<std::pair<std::string, uint32_t>> RegsVector;
    typedef RegsVector::iterator RegsIterator;

    // methods

    uint32_t putVertex(std::string s);

    void putReg(
        std::string id,
        std::string size
        );

    uint32_t get_vertex_count();
    std::vector<std::vector<int>> get_adjacent_matrix();
    std::vector<std::vector<double>> get_adj_weight_matrix();
    bool isGeneric();
    RegsIterator reg_begin();
    RegsIterator reg_end();
    std::vector<std::pair<uint32_t, uint32_t>> get_all_edges();
    static bool ClassOf(const Graph* g);
    static uRef Create(uint32_t n);
};

Inherited Members

public:
    // typedefs

    typedef Graph* Ref;
    typedef std::unique_ptr<Graph> uRef;
    typedef std::shared_ptr<Graph> sRef;
    typedef WeightedGraph<T>* Ref;
    typedef std::unique_ptr<WeightedGraph<T>> uRef;
    typedef std::shared_ptr<WeightedGraph<T>> sRef;

    // enums

    enum Kind;
    enum Type;

    // methods

    uint32_t inDegree(uint32_t i) const;
    uint32_t outDegree(uint32_t i) const;
    uint32_t size() const;
    std::set<uint32_t>& succ(uint32_t i);
    const std::set<uint32_t>& c_succ(uint32_t i) const;
    std::set<uint32_t>& pred(uint32_t i);
    std::set<uint32_t> adj(uint32_t i) const;
    void putEdge(uint32_t i, uint32_t j);
    bool hasEdge(uint32_t i, uint32_t j) const;
    bool isWeighted() const;
    bool isArch() const;
    bool isDirectedGraph() const;
    std::string dotify(std::string name = "Dump") const;
    static bool ClassOf(const Graph* g);
    static uRef Create(uint32_t n, Type ty = Undirected);
    void putEdge(uint32_t i, uint32_t j, T w);
    void setW(uint32_t i, uint32_t j, T w);
    T getW(uint32_t i, uint32_t j) const;
    static bool ClassOf(const Graph* g);
    static uRef Create(uint32_t n, Type ty = Undirected);

Detailed Documentation

This is the base class for the architectures that this project will be supporting.

Methods

bool isGeneric()

Returns true if this is a generic architechture graph, i.e.: it was not created by any of the architechtures compiled within the program.

class QPanda::CPUQVM

Overview

#include <OriginQuantumMachine.h>

class CPUQVM: public QPanda::IdealQVM
{
public:
    // methods

    virtual void init();
};

Inherited Members

public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {}) = 0;
    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {});
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t);
    virtual QMachineStatus* getStatus() const;
    virtual QResult* getResult();
    virtual std::map<std::string, bool> getResultMap();
    virtual void finalize();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<int>&, int);
    virtual std::map<GateType, size_t> getGateTimeMap() const;
    virtual QStat getQState() const;
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*);
    virtual void set_random_engine(RandomEngine* rng);
    virtual void setConfig(const Configuration& config);
    virtual Qubit* allocateQubit();
    virtual QVec allocateQubits(size_t);
    virtual ClassicalCondition allocateCBit();
    virtual std::vector<ClassicalCondition> allocateCBits(size_t);
    virtual ClassicalCondition allocateCBit(size_t);
    virtual size_t getAllocateQubit();
    virtual size_t getAllocateCMem();
    virtual void Free_Qubit(Qubit*);
    virtual void Free_Qubits(QVec&);
    virtual void Free_CBit(ClassicalCondition&);
    virtual void Free_CBits(std::vector<ClassicalCondition>&);
    virtual void setConfigure(const Configuration&);
    virtual Qubit* qAlloc();
    virtual QVec qAllocMany(size_t qubit_count);
    virtual ClassicalCondition cAlloc();
    virtual ClassicalCondition cAlloc(size_t);
    virtual std::vector<ClassicalCondition> cAllocMany(size_t);
    virtual void qFree(Qubit*);
    virtual void qFreeAll(QVec&);
    virtual void cFree(ClassicalCondition&);
    virtual void cFreeAll(std::vector<ClassicalCondition>&);
    virtual size_t getAllocateQubitNum();
    virtual size_t getAllocateCMemNum();
    virtual size_t get_allocate_qubits(QVec&);
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int);
    virtual prob_vec PMeasure_no_index(QVec qubit_vector) = 0;
    virtual prob_tuple getProbTupleList(QVec, int) = 0;
    virtual prob_vec getProbList(QVec, int) = 0;
    virtual prob_dict getProbDict(QVec, int) = 0;
    virtual prob_tuple probRunTupleList(QProg&, QVec, int) = 0;
    virtual prob_vec probRunList(QProg&, QVec, int) = 0;
    virtual prob_dict probRunDict(QProg&, QVec, int) = 0;
    virtual std::map<std::string, size_t> quickMeasure(QVec, size_t) = 0;
    virtual prob_tuple PMeasure(QVec qubit_vector, int select_max) = 0;
    virtual QStat getQStat() = 0;
    virtual prob_tuple getProbTupleList(QVec, int selectMax = -1);
    virtual prob_vec getProbList(QVec, int selectMax = -1);
    virtual prob_dict getProbDict(QVec, int selectMax = -1);
    virtual prob_tuple probRunTupleList(QProg&, QVec, int selectMax = -1);
    virtual prob_vec probRunList(QProg&, QVec, int selectMax = -1);
    virtual prob_dict probRunDict(QProg&, QVec, int selectMax = -1);
    prob_tuple probRunTupleList(QProg&, const std::vector<int>&, int selectMax = -1);
    prob_vec probRunList(QProg&, const std::vector<int>&, int selectMax = -1);
    prob_dict probRunDict(QProg&, const std::vector<int>&, int selectMax = -1);
    virtual std::map<std::string, size_t> quickMeasure(QVec, size_t);
    virtual QStat getQStat();
    virtual prob_tuple PMeasure(QVec qubit_vector, int select_max);
    virtual prob_vec PMeasure_no_index(QVec qubit_vector);
    QStat getQState();
    prob_tuple pMeasure(QVec qubit_vector, int select_max);
    prob_vec pMeasureNoIndex(QVec qubit_vector);

Detailed Documentation

Methods

virtual void init()

init

Returns:

void

class QPanda::CPUSingleThreadQVM

Overview

#include <OriginQuantumMachine.h>

class CPUSingleThreadQVM: public QPanda::IdealQVM
{
public:
    // methods

    virtual void init();
};

Inherited Members

public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {}) = 0;
    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {});
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t);
    virtual QMachineStatus* getStatus() const;
    virtual QResult* getResult();
    virtual std::map<std::string, bool> getResultMap();
    virtual void finalize();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<int>&, int);
    virtual std::map<GateType, size_t> getGateTimeMap() const;
    virtual QStat getQState() const;
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*);
    virtual void set_random_engine(RandomEngine* rng);
    virtual void setConfig(const Configuration& config);
    virtual Qubit* allocateQubit();
    virtual QVec allocateQubits(size_t);
    virtual ClassicalCondition allocateCBit();
    virtual std::vector<ClassicalCondition> allocateCBits(size_t);
    virtual ClassicalCondition allocateCBit(size_t);
    virtual size_t getAllocateQubit();
    virtual size_t getAllocateCMem();
    virtual void Free_Qubit(Qubit*);
    virtual void Free_Qubits(QVec&);
    virtual void Free_CBit(ClassicalCondition&);
    virtual void Free_CBits(std::vector<ClassicalCondition>&);
    virtual void setConfigure(const Configuration&);
    virtual Qubit* qAlloc();
    virtual QVec qAllocMany(size_t qubit_count);
    virtual ClassicalCondition cAlloc();
    virtual ClassicalCondition cAlloc(size_t);
    virtual std::vector<ClassicalCondition> cAllocMany(size_t);
    virtual void qFree(Qubit*);
    virtual void qFreeAll(QVec&);
    virtual void cFree(ClassicalCondition&);
    virtual void cFreeAll(std::vector<ClassicalCondition>&);
    virtual size_t getAllocateQubitNum();
    virtual size_t getAllocateCMemNum();
    virtual size_t get_allocate_qubits(QVec&);
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int);
    virtual prob_vec PMeasure_no_index(QVec qubit_vector) = 0;
    virtual prob_tuple getProbTupleList(QVec, int) = 0;
    virtual prob_vec getProbList(QVec, int) = 0;
    virtual prob_dict getProbDict(QVec, int) = 0;
    virtual prob_tuple probRunTupleList(QProg&, QVec, int) = 0;
    virtual prob_vec probRunList(QProg&, QVec, int) = 0;
    virtual prob_dict probRunDict(QProg&, QVec, int) = 0;
    virtual std::map<std::string, size_t> quickMeasure(QVec, size_t) = 0;
    virtual prob_tuple PMeasure(QVec qubit_vector, int select_max) = 0;
    virtual QStat getQStat() = 0;
    virtual prob_tuple getProbTupleList(QVec, int selectMax = -1);
    virtual prob_vec getProbList(QVec, int selectMax = -1);
    virtual prob_dict getProbDict(QVec, int selectMax = -1);
    virtual prob_tuple probRunTupleList(QProg&, QVec, int selectMax = -1);
    virtual prob_vec probRunList(QProg&, QVec, int selectMax = -1);
    virtual prob_dict probRunDict(QProg&, QVec, int selectMax = -1);
    prob_tuple probRunTupleList(QProg&, const std::vector<int>&, int selectMax = -1);
    prob_vec probRunList(QProg&, const std::vector<int>&, int selectMax = -1);
    prob_dict probRunDict(QProg&, const std::vector<int>&, int selectMax = -1);
    virtual std::map<std::string, size_t> quickMeasure(QVec, size_t);
    virtual QStat getQStat();
    virtual prob_tuple PMeasure(QVec qubit_vector, int select_max);
    virtual prob_vec PMeasure_no_index(QVec qubit_vector);
    QStat getQState();
    prob_tuple pMeasure(QVec qubit_vector, int select_max);
    prob_vec pMeasureNoIndex(QVec qubit_vector);

Detailed Documentation

Methods

virtual void init()

init

Returns:

void

class QPanda::Configuration

Overview

Quantum qubit and cbit Configuration. More…

#include <QuantumMachineInterface.h>

class Configuration
{
public:
    // fields

    size_t maxQubit = 25;
    size_t maxCMem = 25;
};

Detailed Documentation

Quantum qubit and cbit Configuration.

Default number is 25

See also:

QVM

Fields

size_t maxQubit = 25

Config max qubit num

size_t maxCMem = 25

Config max cbit num

class QPanda::CutQCircuit

struct QPanda::CutQCircuit::CutFragment

Overview

struct CutFragment
{
    // fields

    std::set<uint32_t> m_vertice;
    std::set<uint32_t> m_qubit;
    std::set<uint32_t> m_prep_qubit;
    std::set<uint32_t> m_meas_qubit;
    std::map<uint32_t, uint32_t> m_auxi_qubit_map;
    QCircuit m_cir;
};

Detailed Documentation

Fields

std::set<uint32_t> m_prep_qubit

preparation-qubit fragment

std::set<uint32_t> m_meas_qubit

measure-qubit

#include <CutQC.h>

class CutQCircuit
{
public:
    // structs

    struct CutFragment;

    // construction

    CutQCircuit(const QProgDAG& prog_dag);

    // methods

    void cut_circuit(
        const std::map<uint32_t, std::vector<uint32_t>>& cut_pos,
        const std::vector<std::vector<uint32_t>>& sub_graph_vertice,
        QuantumMachine* qvm
        );

    void generate_subcircuits(QuantumMachine* qvm);
    const std::vector<SubCircuit>& get_cutted_sub_circuits(std::vector<uint32_t>& qubit_permutation);
    std::vector<StitchesInfo> get_stitches(const std::map<uint32_t, std::vector<uint32_t>>& cut_pos);
};

class QPanda::DecomposeControlSingleQGateIntoMetadataDoubleQGate

struct QPanda::DecomposeControlSingleQGateIntoMetadataDoubleQGate::SpecialSingGate

struct SpecialSingGate
{
    // fields

    double m_alpha;
    double m_beta;
    double m_delta;
    double m_gamma;

    // methods

    std::vector<double> parse_angle(
        double alpha,
        double beta,
        double delta,
        double gamma
        ) const;
};

Overview

#include <TransformDecomposition.h>

class DecomposeControlSingleQGateIntoMetadataDoubleQGate: public QPanda::TraversalInterface
{
public:
    // structs

    struct SpecialSingGate;

    // construction

    DecomposeControlSingleQGateIntoMetadataDoubleQGate(
        QuantumMachine* quantum_machine,
        std::vector<std::vector<std::string>> valid_qgate_matrix,
        const std::string& config_data = CONFIG_PATH
        );

    // methods

    void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Methods

void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class QPanda::DeleteUnitQNode

Overview

#include <TransformDecomposition.h>

class DeleteUnitQNode: public QPanda::TraversalInterface
{
public:
    // methods

    void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node);
    virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

Detailed Documentation

Methods

void execute(std::shared_ptr<AbstractQGateNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qgatenode.

Parameters:

AbstractQGateNode*	quantum gate
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumMeasure> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal measure node.

Parameters:

AbstractQuantumMeasure*	measure node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumReset> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal reset node.

Parameters:

AbstractQuantumReset*	reset node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractControlFlowNode> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal control flow node.

Parameters:

AbstractControlFlowNode*	control flow node
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumCircuit> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qcircuit.

Parameters:

AbstractQuantumCircuit*	quantum circuit
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractQuantumProgram> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractQuantumProgram*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

virtual void execute(std::shared_ptr<AbstractClassicalProg> cur_node, std::shared_ptr<QNode> parent_node)

Execution traversal qprog.

Parameters:

AbstractClassicalProg*	quantum prog
AbstractQGateNode*	quantum gate

Returns:

void

class QPanda::DiffusionCirBuilder

#include <DiffusionCircuit.h>

class DiffusionCirBuilder: public QPanda::AbstractDiffusionOperator
{
public:
    // methods

    virtual QCircuit build_diffusion_circuit(const QVec& qvec);
};

Inherited Members

public:
    // methods

    virtual QCircuit build_diffusion_circuit(const QVec& qvec) = 0;

class QPanda::DynamicQCircuitGraph

#include <QubitMapping.h>

class DynamicQCircuitGraph
{
public:
    // construction

    DynamicQCircuitGraph(QProg prog);
    DynamicQCircuitGraph(const DynamicQCircuitGraph& c);

    // methods

    FrontLayer& get_front_layer();
    const FrontLayer& get_front_layer_c() const;
    const PressedTopoSeq& get_layer_topo_seq() const;
};

class QPanda::FindSubCircuit

Overview

#include <QCircuitOptimize.h>

class FindSubCircuit
{
public:
    // typedefs

    typedef SeqNode<T> MatchNode;
    typedef std::vector<MatchNode<T>> MatchNodeVec;
    typedef std::vector<std::pair<pOptimizerNodeInfo, MatchNodeVec<pOptimizerNodeInfo>>> MatchNodeTable;

    // construction

    FindSubCircuit(LayeredTopoSeq& topolog_sequence);

    // methods

    void sub_cir_query(LayeredTopoSeq& sub_sequence);

    bool node_match(
        const SeqNode<pOptimizerNodeInfo>& target_seq_node,
        const SeqNode<pOptimizerNodeInfo>& graph_node
        );

    bool check_angle(
        const pOptimizerNodeInfo node_1,
        const pOptimizerNodeInfo node_2
        );

    void match_layer(SeqLayer<pOptimizerNodeInfo>& sub_seq_layer, const size_t match_layer, std::vector<LayeredTopoSeq>& sub_graph_vec);

    void merge_sub_graph_vec(
        std::vector<LayeredTopoSeq>& sub_graph_vec,
        const size_t match_layer,
        LayeredTopoSeq& target_sub_sequence
        );

    void clean_sub_graph_vec(std::vector<LayeredTopoSeq>& sub_graph_vec, LayeredTopoSeq& target_sub_sequence);
    void merge_topolog_sequence(LayeredTopoSeq& src_seq, LayeredTopoSeq& dst_seq);
    const std::vector<LayeredTopoSeq>& get_sub_graph_vec();
    void clear();
};

Detailed Documentation

Methods

void sub_cir_query(LayeredTopoSeq& sub_sequence)

Query the subgraph and store the query results in query_Result.

Parameters:

LayeredTopoSeq&

store the query results

Returns:

void match_layer(
    SeqLayer<pOptimizerNodeInfo>& sub_seq_layer,
    const size_t match_layer,
    std::vector<LayeredTopoSeq>& sub_graph_vec
    )

Layer matching: matching and combining the nodes of each layer of the sub graph.

Parameters:

SeqLayer<pOptimizerNodeInfo>&	the target matching sub-seq-layer
const	size_t the current matching layer
std::vector<LayeredTopoSeq>&	sub-graph vector

Returns:

void merge_sub_graph_vec(
    std::vector<LayeredTopoSeq>& sub_graph_vec,
    const size_t match_layer,
    LayeredTopoSeq& target_sub_sequence
    )

Merge incomplete subgraphs Implementation method: get the node set of the next layer of each subgraph of the matching subgraph set. If the node set of the next layer of the two subgraphs has duplicate elements, merge the two subgraphs.

Parameters:

std::vector<LayeredTopoSeq>&	the sub graph vector
const	size_t the target layer
LayeredTopoSeq&	the target sub-sequence

Returns:

void clean_sub_graph_vec(std::vector<LayeredTopoSeq>& sub_graph_vec, LayeredTopoSeq& target_sub_sequence)

Clean up the result set of matching subgraphs and delete the wrong matches.

Parameters:

std::vector<LayeredTopoSeq>&	the result set of matching subgraphs
LayeredTopoSeq&	the target sub-sequence

Returns:

void merge_topolog_sequence(LayeredTopoSeq& src_seq, LayeredTopoSeq& dst_seq)

merge sub-graph: merging src_seq into dst_seq by layer

Parameters:

LayeredTopoSeq&	the src_seq
LayeredTopoSeq&	dst_seq

Returns:

class QPanda::FragmentResult

#include <CutQC.h>

class FragmentResult
{
public:
    // fields

    std::vector<PrepState> m_prep_state;
    std::vector<MeasBasis> m_meas_basis;
    std::map<std::string, size_t> m_result;

    // construction

    FragmentResult(
        size_t prep_num,
        size_t meas_num
        );

    // methods

    void set_meas_label(
        size_t meas_qubit,
        MeasBasis basis
        );

    void set_prep_label(
        size_t prep_qubit,
        PrepState state
        );
};

class QPanda::FrontLayer

#include <QubitMapping.h>

class FrontLayer
{
public:
    // methods

    const pPressedCirNode& operator [] (uint32_t i) const;
    uint32_t size() const;
    const std::vector<pPressedCirNode>& get_front_layer_nodes() const;
    void remove_node(pPressedCirNode p_node);
    uint32_t remove_node(uint32_t i);
};

class QPanda::GPUQVM

Overview

#include <OriginQuantumMachine.h>

class GPUQVM: public QPanda::IdealQVM
{
public:
    // methods

    virtual void init();
};

Inherited Members

public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {}) = 0;
    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {});
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t);
    virtual QMachineStatus* getStatus() const;
    virtual QResult* getResult();
    virtual std::map<std::string, bool> getResultMap();
    virtual void finalize();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<int>&, int);
    virtual std::map<GateType, size_t> getGateTimeMap() const;
    virtual QStat getQState() const;
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*);
    virtual void set_random_engine(RandomEngine* rng);
    virtual void setConfig(const Configuration& config);
    virtual Qubit* allocateQubit();
    virtual QVec allocateQubits(size_t);
    virtual ClassicalCondition allocateCBit();
    virtual std::vector<ClassicalCondition> allocateCBits(size_t);
    virtual ClassicalCondition allocateCBit(size_t);
    virtual size_t getAllocateQubit();
    virtual size_t getAllocateCMem();
    virtual void Free_Qubit(Qubit*);
    virtual void Free_Qubits(QVec&);
    virtual void Free_CBit(ClassicalCondition&);
    virtual void Free_CBits(std::vector<ClassicalCondition>&);
    virtual void setConfigure(const Configuration&);
    virtual Qubit* qAlloc();
    virtual QVec qAllocMany(size_t qubit_count);
    virtual ClassicalCondition cAlloc();
    virtual ClassicalCondition cAlloc(size_t);
    virtual std::vector<ClassicalCondition> cAllocMany(size_t);
    virtual void qFree(Qubit*);
    virtual void qFreeAll(QVec&);
    virtual void cFree(ClassicalCondition&);
    virtual void cFreeAll(std::vector<ClassicalCondition>&);
    virtual size_t getAllocateQubitNum();
    virtual size_t getAllocateCMemNum();
    virtual size_t get_allocate_qubits(QVec&);
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int);
    virtual prob_vec PMeasure_no_index(QVec qubit_vector) = 0;
    virtual prob_tuple getProbTupleList(QVec, int) = 0;
    virtual prob_vec getProbList(QVec, int) = 0;
    virtual prob_dict getProbDict(QVec, int) = 0;
    virtual prob_tuple probRunTupleList(QProg&, QVec, int) = 0;
    virtual prob_vec probRunList(QProg&, QVec, int) = 0;
    virtual prob_dict probRunDict(QProg&, QVec, int) = 0;
    virtual std::map<std::string, size_t> quickMeasure(QVec, size_t) = 0;
    virtual prob_tuple PMeasure(QVec qubit_vector, int select_max) = 0;
    virtual QStat getQStat() = 0;
    virtual prob_tuple getProbTupleList(QVec, int selectMax = -1);
    virtual prob_vec getProbList(QVec, int selectMax = -1);
    virtual prob_dict getProbDict(QVec, int selectMax = -1);
    virtual prob_tuple probRunTupleList(QProg&, QVec, int selectMax = -1);
    virtual prob_vec probRunList(QProg&, QVec, int selectMax = -1);
    virtual prob_dict probRunDict(QProg&, QVec, int selectMax = -1);
    prob_tuple probRunTupleList(QProg&, const std::vector<int>&, int selectMax = -1);
    prob_vec probRunList(QProg&, const std::vector<int>&, int selectMax = -1);
    prob_dict probRunDict(QProg&, const std::vector<int>&, int selectMax = -1);
    virtual std::map<std::string, size_t> quickMeasure(QVec, size_t);
    virtual QStat getQStat();
    virtual prob_tuple PMeasure(QVec qubit_vector, int select_max);
    virtual prob_vec PMeasure_no_index(QVec qubit_vector);
    QStat getQState();
    prob_tuple pMeasure(QVec qubit_vector, int select_max);
    prob_vec pMeasureNoIndex(QVec qubit_vector);

Detailed Documentation

Methods

virtual void init()

init

Returns:

void

class QPanda::GetQubitTopology

#include <GetQubitTopology.h>

class GetQubitTopology
{
public:
    // methods

    void init();
    const TopologyData& get_src_adjaccent_matrix(QProg prog);
};

class QPanda::Graph

enum QPanda::Graph::Kind

#include <Graph.h>

enum Kind
{
    K_GRAPH,
    K_WEIGHTED,
    K_ARCH,
};

enum QPanda::Graph::Type

#include <Graph.h>

enum Type
{
    Directed,
    Undirected,
};

#include <Graph.h>

class Graph
{
public:
    // typedefs

    typedef Graph* Ref;
    typedef std::unique_ptr<Graph> uRef;
    typedef std::shared_ptr<Graph> sRef;

    // enums

    enum Kind;
    enum Type;

    // construction

    Graph(
        uint32_t n,
        Type ty = Undirected
        );

    // methods

    uint32_t inDegree(uint32_t i) const;
    uint32_t outDegree(uint32_t i) const;
    uint32_t size() const;
    std::set<uint32_t>& succ(uint32_t i);
    const std::set<uint32_t>& c_succ(uint32_t i) const;
    std::set<uint32_t>& pred(uint32_t i);
    std::set<uint32_t> adj(uint32_t i) const;

    void putEdge(
        uint32_t i,
        uint32_t j
        );

    bool hasEdge(
        uint32_t i,
        uint32_t j
        ) const;

    bool isWeighted() const;
    bool isArch() const;
    bool isDirectedGraph() const;
    std::string dotify(std::string name = "Dump") const;
    static bool ClassOf(const Graph* g);

    static uRef Create(
        uint32_t n,
        Type ty = Undirected
        );
};

// direct descendants

template <typename T>
class WeightedGraph;

class QPanda::HHLAlg

Overview

#include <HHL.h>

class HHLAlg
{
public:
    // construction

    HHLAlg(
        const QStat& A,
        const std::vector<double>& b,
        QuantumMachine* qvm
        );

    // methods

    QCircuit get_hhl_circuit(uint32_t precision_cnt = 0);
    std::string check_QPE_result();
    const double& get_amplification_factor() const;
    static void expand_linear_equations(QStat& A, std::vector<double>& b);
};

Detailed Documentation

Methods

static void expand_linear_equations(QStat& A, std::vector<double>& b)

Extending linear equations to N dimension, N=2^n.

Parameters:

QStat&	the source matrix, which will be extend to N*N, N=2^n
std::vector<double>&	the source vector b, which will be extend to 2^n

Returns:

class QPanda::IdealMachineInterface

#include <QuantumMachineInterface.h>

class IdealMachineInterface
{
public:
    // methods

    virtual prob_vec PMeasure_no_index(QVec qubit_vector) = 0;

    virtual prob_tuple getProbTupleList(
        QVec,
        int
        ) = 0;

    virtual prob_vec getProbList(
        QVec,
        int
        ) = 0;

    virtual prob_dict getProbDict(
        QVec,
        int
        ) = 0;

    virtual prob_tuple probRunTupleList(
        QProg&,
        QVec,
        int
        ) = 0;

    virtual prob_vec probRunList(
        QProg&,
        QVec,
        int
        ) = 0;

    virtual prob_dict probRunDict(
        QProg&,
        QVec,
        int
        ) = 0;

    virtual std::map<std::string, size_t> quickMeasure(
        QVec,
        size_t
        ) = 0;

    virtual prob_tuple PMeasure(
        QVec qubit_vector,
        int select_max
        ) = 0;

    virtual QStat getQStat() = 0;
};

// direct descendants

class IdealQVM;

class QPanda::IdealQVM

#include <OriginQuantumMachine.h>

class IdealQVM:
    public QPanda::QVM,
    public QPanda::IdealMachineInterface
{
public:
    // methods

    virtual prob_tuple getProbTupleList(
        QVec,
        int selectMax = -1
        );

    virtual prob_vec getProbList(
        QVec,
        int selectMax = -1
        );

    virtual prob_dict getProbDict(
        QVec,
        int selectMax = -1
        );

    virtual prob_tuple probRunTupleList(
        QProg&,
        QVec,
        int selectMax = -1
        );

    virtual prob_vec probRunList(
        QProg&,
        QVec,
        int selectMax = -1
        );

    virtual prob_dict probRunDict(
        QProg&,
        QVec,
        int selectMax = -1
        );

    prob_tuple probRunTupleList(
        QProg&,
        const std::vector<int>&,
        int selectMax = -1
        );

    prob_vec probRunList(
        QProg&,
        const std::vector<int>&,
        int selectMax = -1
        );

    prob_dict probRunDict(
        QProg&,
        const std::vector<int>&,
        int selectMax = -1
        );

    virtual std::map<std::string, size_t> quickMeasure(
        QVec,
        size_t
        );

    virtual QStat getQStat();

    virtual prob_tuple PMeasure(
        QVec qubit_vector,
        int select_max
        );

    virtual prob_vec PMeasure_no_index(QVec qubit_vector);
    QStat getQState();

    prob_tuple pMeasure(
        QVec qubit_vector,
        int select_max
        );

    prob_vec pMeasureNoIndex(QVec qubit_vector);
};

// direct descendants

class CPUQVM;
class CPUSingleThreadQVM;
class GPUQVM;
class MPSQVM;

Inherited Members

public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {}) = 0;
    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {});
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t);
    virtual QMachineStatus* getStatus() const;
    virtual QResult* getResult();
    virtual std::map<std::string, bool> getResultMap();
    virtual void finalize();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<int>&, int);
    virtual std::map<GateType, size_t> getGateTimeMap() const;
    virtual QStat getQState() const;
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*);
    virtual void set_random_engine(RandomEngine* rng);
    virtual void setConfig(const Configuration& config);
    virtual Qubit* allocateQubit();
    virtual QVec allocateQubits(size_t);
    virtual ClassicalCondition allocateCBit();
    virtual std::vector<ClassicalCondition> allocateCBits(size_t);
    virtual ClassicalCondition allocateCBit(size_t);
    virtual size_t getAllocateQubit();
    virtual size_t getAllocateCMem();
    virtual void Free_Qubit(Qubit*);
    virtual void Free_Qubits(QVec&);
    virtual void Free_CBit(ClassicalCondition&);
    virtual void Free_CBits(std::vector<ClassicalCondition>&);
    virtual void setConfigure(const Configuration&);
    virtual Qubit* qAlloc();
    virtual QVec qAllocMany(size_t qubit_count);
    virtual ClassicalCondition cAlloc();
    virtual ClassicalCondition cAlloc(size_t);
    virtual std::vector<ClassicalCondition> cAllocMany(size_t);
    virtual void qFree(Qubit*);
    virtual void qFreeAll(QVec&);
    virtual void cFree(ClassicalCondition&);
    virtual void cFreeAll(std::vector<ClassicalCondition>&);
    virtual size_t getAllocateQubitNum();
    virtual size_t getAllocateCMemNum();
    virtual size_t get_allocate_qubits(QVec&);
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int);
    virtual prob_vec PMeasure_no_index(QVec qubit_vector) = 0;
    virtual prob_tuple getProbTupleList(QVec, int) = 0;
    virtual prob_vec getProbList(QVec, int) = 0;
    virtual prob_dict getProbDict(QVec, int) = 0;
    virtual prob_tuple probRunTupleList(QProg&, QVec, int) = 0;
    virtual prob_vec probRunList(QProg&, QVec, int) = 0;
    virtual prob_dict probRunDict(QProg&, QVec, int) = 0;
    virtual std::map<std::string, size_t> quickMeasure(QVec, size_t) = 0;
    virtual prob_tuple PMeasure(QVec qubit_vector, int select_max) = 0;
    virtual QStat getQStat() = 0;

template class QPanda::JsonParser

#include <Graph.h>

template <class T>
class JsonParser
{
public:
    // methods

    static std::unique_ptr<T> ParseString(std::string str);
    static std::unique_ptr<T> ParseFile(std::string filename);
};

class QPanda::JudgeTwoNodeIterIsSwappable

struct QPanda::JudgeTwoNodeIterIsSwappable::NodeInCircuitInfo

struct NodeInCircuitInfo
{
    // fields

    bool m_in_circuit;
    bool m_dagger;
};

class QPanda::JudgeTwoNodeIterIsSwappable::AbstractJudgeStatueInterface

class AbstractJudgeStatueInterface
{
public:
    // methods

    virtual void handle_QGate(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void handle_QMeasure(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void handle_QReset(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void enter_flow_ctrl_node();
    virtual void leave_flow_ctrl_node();

    virtual void on_enter_circuit(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        QCircuitParam& cir_param
        );

    virtual void on_leave_circuit(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        QCircuitParam& cir_param
        );

    virtual void on_enter_prog(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param
        );

    virtual void on_leave_prog(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param
        );

    virtual void on_traversal_end();
    virtual ResultStatue get_statue() const = 0;
};

class QPanda::JudgeTwoNodeIterIsSwappable::CanNotBeExchange

class CanNotBeExchange: public QPanda::JudgeTwoNodeIterIsSwappable::AbstractJudgeStatueInterface
{
public:
    // construction

    CanNotBeExchange(
        JudgeTwoNodeIterIsSwappable& parent,
        ResultStatue s
        );

    // methods

    ResultStatue get_statue() const;
};

class QPanda::JudgeTwoNodeIterIsSwappable::CoubleBeExchange

class CoubleBeExchange: public QPanda::JudgeTwoNodeIterIsSwappable::AbstractJudgeStatueInterface
{
public:
    // construction

    CoubleBeExchange(
        JudgeTwoNodeIterIsSwappable& parent,
        ResultStatue s
        );

    // methods

    ResultStatue get_statue() const;
};

class QPanda::JudgeTwoNodeIterIsSwappable::OnFoundAllNodes

class OnFoundAllNodes: public QPanda::JudgeTwoNodeIterIsSwappable::AbstractJudgeStatueInterface
{
public:
    // construction

    OnFoundAllNodes(
        JudgeTwoNodeIterIsSwappable& parent,
        ResultStatue s
        );

    // methods

    void on_traversal_end();
    ResultStatue get_statue() const;
};

class QPanda::JudgeTwoNodeIterIsSwappable::OnInitStatue

class OnInitStatue: public QPanda::JudgeTwoNodeIterIsSwappable::AbstractJudgeStatueInterface
{
public:
    // construction

    OnInitStatue(
        JudgeTwoNodeIterIsSwappable& parent,
        ResultStatue s
        );

    // methods

    void handle_QGate(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void handle_QMeasure(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void handle_QReset(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    ResultStatue get_statue() const;
};

class QPanda::JudgeTwoNodeIterIsSwappable::OnJudgeMatrix

class OnJudgeMatrix: public QPanda::JudgeTwoNodeIterIsSwappable::AbstractJudgeStatueInterface
{
public:
    // construction

    OnJudgeMatrix(
        JudgeTwoNodeIterIsSwappable& parent,
        ResultStatue s
        );

    // methods

    void on_traversal_end();
    ResultStatue get_statue() const;
};

class QPanda::JudgeTwoNodeIterIsSwappable::OnPickUpNode

class OnPickUpNode: public QPanda::JudgeTwoNodeIterIsSwappable::AbstractJudgeStatueInterface
{
public:
    // construction

    OnPickUpNode(
        JudgeTwoNodeIterIsSwappable& parent,
        ResultStatue s
        );

    // methods

    void handle_QGate(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void handle_QMeasure(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void handle_QReset(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void enter_flow_ctrl_node();
    void leave_flow_ctrl_node();

    void on_enter_circuit(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        QCircuitParam& cir_param
        );

    void on_leave_circuit(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        QCircuitParam& cir_param
        );

    void on_enter_prog(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param
        );

    void on_leave_prog(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param
        );

    ResultStatue get_statue() const;
};

Overview

Judge two node is swappable. More…

#include <JudgeTwoNodeIterIsSwappable.h>

class JudgeTwoNodeIterIsSwappable: public QPanda::TraverseByNodeIter
{
public:
    // structs

    struct NodeInCircuitInfo;

    // classes

    class AbstractJudgeStatueInterface;
    class CanNotBeExchange;
    class CoubleBeExchange;
    class OnFoundAllNodes;
    class OnInitStatue;
    class OnJudgeMatrix;
    class OnPickUpNode;

    // construction

    JudgeTwoNodeIterIsSwappable(QProg prog, NodeIter& nodeItr_1, NodeIter& nodeItr_2);

    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    bool get_result();
    virtual void traverse_qprog();
    bool judge_node_type();
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);

Detailed Documentation

Judge two node is swappable.

Construction

JudgeTwoNodeIterIsSwappable(QProg prog, NodeIter& nodeItr_1, NodeIter& nodeItr_2)

Constructor of JudgeTwoNodeIterIsSwappable.

Methods

bool get_result()

get final judge result

Returns:

bool

virtual void traverse_qprog()

start traverse a quantum prog

bool judge_node_type()

judge the input two node type

Returns:

if any input node is unswappable type, return false, else return true.

class QPanda::KarusError

#include <NoiseSimulator.h>

class KarusError
{
public:
    // construction

    KarusError();
    KarusError(const std::vector<QStat>&);

    KarusError(
        const std::vector<QStat>&,
        const std::vector<double>&
        );

    // methods

    bool has_karus_error();
    void set_unitary_probs(std::vector<double>& probs_vec);
    void get_unitary_probs(std::vector<double>& probs_vec) const;
    void set_unitary_matrices(std::vector<QStat>& unitary_matrices);
    void get_unitary_matrices(std::vector<QStat>& unitary_matrices) const;
    void set_karus_matrices(std::vector<QStat>& karus_matrices);
    void get_karus_matrices(std::vector<QStat>& karus_matrices) const;
    KarusError tensor(const KarusError& karus_error);
    KarusError expand(const KarusError& karus_error);
    KarusError compose(const KarusError& karus_error);
    size_t get_qubit_num() const;
    KarusErrorType get_karus_error_type();
};

class QPanda::MultiPrecisionMachineInterface

#include <QuantumMachineInterface.h>

class MultiPrecisionMachineInterface
{
public:
    // methods

    virtual stat_map getQState() = 0;
    virtual qstate_type pMeasureBinIndex(std::string) = 0;
    virtual qstate_type pMeasureDecIndex(std::string) = 0;
    virtual prob_map PMeasure(std::string) = 0;

    virtual prob_map PMeasure(
        QVec,
        std::string
        ) = 0;

    virtual prob_map getProbDict(
        QVec,
        std::string
        ) = 0;

    virtual prob_map probRunDict(
        QProg&,
        QVec,
        std::string
        ) = 0;
};

class QPanda::NodeIter

#include <QNode.h>

class NodeIter
{
public:
    // construction

    NodeIter(Item* pItem);
    NodeIter(const NodeIter& oldIter);
    NodeIter();

    // methods

    Item* getPCur() const;
    void setPCur(Item* pItem);
    NodeIter& operator ++ ();
    NodeIter operator ++ (int);
    std::shared_ptr<QNode> operator * () const;
    NodeIter& operator -- ();
    NodeIter operator -- (int);
    NodeIter getNextIter();
    bool operator != (NodeIter) const;
    bool operator == (NodeIter) const;
};

class QPanda::NoiseQVM

Overview

#include <OriginQuantumMachine.h>

class NoiseQVM: public QPanda::QVM
{
public:
    // methods

    virtual void init();
    void init(rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);

    virtual std::map<std::string, size_t> runWithConfiguration(
        QProg& prog,
        std::vector<int>&,
        int
        );

    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual void run(QProg& prog);

    void set_noise_model(
        const NOISE_MODEL& model,
        const GateType& type,
        double prob
        );

    void set_noise_model(
        const NOISE_MODEL& model,
        const GateType& type,
        double prob,
        const QVec& qubits
        );

    void set_noise_model(
        const NOISE_MODEL& model,
        const GateType& type,
        double prob,
        const std::vector<QVec>& qubits
        );

    void set_noise_model(
        const NOISE_MODEL& model,
        const GateType& type,
        double T1,
        double T2,
        double t_gate
        );

    void set_noise_model(
        const NOISE_MODEL& model,
        const GateType& type,
        double T1,
        double T2,
        double t_gate,
        const QVec& qubits
        );

    void set_noise_model(
        const NOISE_MODEL& model,
        const GateType& type,
        double T1,
        double T2,
        double t_gate,
        const std::vector<QVec>& qubits
        );

    void set_measure_error(
        const NOISE_MODEL& model,
        double prob,
        const QVec& qubits = {}
        );

    void set_measure_error(
        const NOISE_MODEL& model,
        double T1,
        double T2,
        double t_gate,
        const QVec& qubits = {}
        );

    void set_mixed_unitary_error(
        const GateType& type,
        const std::vector<QStat>& unitary_matrices,
        const std::vector<double>& probs
        );

    void set_mixed_unitary_error(
        const GateType& type,
        const std::vector<QStat>& unitary_matrices,
        const std::vector<double>& probs,
        const QVec& qubits
        );

    void set_mixed_unitary_error(
        const GateType& type,
        const std::vector<QStat>& unitary_matrices,
        const std::vector<double>& probs,
        const std::vector<QVec>& qubits
        );

    void set_reset_error(
        double p0,
        double p1,
        const QVec& qubits = {}
        );

    void set_readout_error(
        const std::vector<std::vector<double>>& probs_list,
        const QVec& qubits = {}
        );

    void set_rotation_error(double error);
};

Inherited Members

public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {}) = 0;
    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {});
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t);
    virtual QMachineStatus* getStatus() const;
    virtual QResult* getResult();
    virtual std::map<std::string, bool> getResultMap();
    virtual void finalize();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<int>&, int);
    virtual std::map<GateType, size_t> getGateTimeMap() const;
    virtual QStat getQState() const;
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*);
    virtual void set_random_engine(RandomEngine* rng);
    virtual void setConfig(const Configuration& config);
    virtual Qubit* allocateQubit();
    virtual QVec allocateQubits(size_t);
    virtual ClassicalCondition allocateCBit();
    virtual std::vector<ClassicalCondition> allocateCBits(size_t);
    virtual ClassicalCondition allocateCBit(size_t);
    virtual size_t getAllocateQubit();
    virtual size_t getAllocateCMem();
    virtual void Free_Qubit(Qubit*);
    virtual void Free_Qubits(QVec&);
    virtual void Free_CBit(ClassicalCondition&);
    virtual void Free_CBits(std::vector<ClassicalCondition>&);
    virtual void setConfigure(const Configuration&);
    virtual Qubit* qAlloc();
    virtual QVec qAllocMany(size_t qubit_count);
    virtual ClassicalCondition cAlloc();
    virtual ClassicalCondition cAlloc(size_t);
    virtual std::vector<ClassicalCondition> cAllocMany(size_t);
    virtual void qFree(Qubit*);
    virtual void qFreeAll(QVec&);
    virtual void cFree(ClassicalCondition&);
    virtual void cFreeAll(std::vector<ClassicalCondition>&);
    virtual size_t getAllocateQubitNum();
    virtual size_t getAllocateCMemNum();
    virtual size_t get_allocate_qubits(QVec&);
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int);

Detailed Documentation

Methods

virtual void init()

init

Returns:

void

virtual std::map<std::string, size_t> runWithConfiguration(
    QProg&,
    std::vector<ClassicalCondition>&,
    rapidjson::Document&
    )

runWithConfiguration

Parameters:

QProg&	quantum program
std::vector<ClassicalCondition>&
rapidjson::Document&

Returns:

std::map<std::string, Eigen::size_t>

virtual std::map<std::string, size_t> runWithConfiguration(
    QProg&,
    std::vector<ClassicalCondition>&,
    int
    )

runWithConfiguration

Parameters:

QProg&	quantum program
std::vector<ClassicalCondition>&
int

Returns:

std::map<std::string, Eigen::size_t>

virtual std::map<std::string, bool> directlyRun(QProg& qProg)

directlyRun

Parameters:

QProg&

quantum program

Returns:

std::map<std::string, bool>

void set_rotation_error(double error)

set QGate rotation angle errors

Parameters:

double

rotation angle errors

Returns:

void

See also:

QNode

class QPanda::NoiseSimulator

#include <NoiseSimulator.h>

class NoiseSimulator: public QPanda::TraversalInterface
{
public:
    // methods

    bool has_quantum_error();
    void set_rotation_error(double);

    void set_measure_error(
        NOISE_MODEL model,
        double param
        );

    void set_measure_error(
        NOISE_MODEL model,
        double param,
        const Qnum& qubits_vec
        );

    void set_measure_error(
        NOISE_MODEL model,
        double T1,
        double T2,
        double time_param
        );

    void set_measure_error(
        NOISE_MODEL model,
        double T1,
        double T2,
        double time_param,
        const Qnum& qubits_vec
        );

    void set_reset_error(
        double,
        double
        );

    void set_readout_error(
        const std::vector<std::vector<double>>& readout_params,
        const Qnum& qubits
        );

    void set_combining_error(
        GateType gate_type,
        const KarusError& karus_error,
        const std::vector<Qnum>& qubits_vecs
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>& karus_matrices
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>& unitary_matrices,
        const std::vector<double>& probs_vec
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>& karus_matrices,
        const std::vector<Qnum>& qubits_vecs
        );

    void set_mixed_unitary_error(
        GateType gate_type,
        const std::vector<QStat>& unitary_matrices,
        const std::vector<double>& probs_vec,
        const std::vector<Qnum>& qubits_vecs
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double param
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double param,
        const Qnum& qubits_vec
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double param,
        const std::vector<Qnum>& qubits_vecs
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double T1,
        double T2,
        double time_param
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double T1,
        double T2,
        double time_param,
        const Qnum& qubits_vecs
        );

    void set_noise_model(
        NOISE_MODEL model,
        GateType gate_type,
        double T1,
        double T2,
        double time_param,
        const std::vector<Qnum>& qubits_vecs
        );

    void set_mps_qpu_and_result(
        std::shared_ptr<MPSImplQPU> mps_qpu,
        QResult* result
        );

    void execute(
        std::shared_ptr<AbstractQGateNode>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractClassicalProg>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumMeasure>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumReset>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumCircuit>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractQuantumProgram>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );

    void execute(
        std::shared_ptr<AbstractControlFlowNode>,
        std::shared_ptr<QNode>,
        QCircuitConfig& config
        );
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

class QPanda::NonKarusError

#include <NoiseSimulator.h>

class NonKarusError
{
public:
    // methods

    bool has_non_karus_error();
    void set_rotation_error(double param);
    double get_rotation_error();

    void set_reset_error(
        double p0_param,
        double p1_param
        );

    double get_reset_p0_error();
    double get_reset_p1_error();
    bool has_measure_qubit(size_t qubit);
    void set_measure_qubit(const Qnum& qubits);
    bool has_measure_error();

    void set_measure_error(
        int qubit,
        std::vector<QStat>& karus_matrices
        );

    void get_measure_error(
        int qubit,
        std::vector<QStat>& karus_matrices
        );

    bool has_readout_error();

    bool get_readout_result(
        bool result,
        size_t qubit
        );

    void set_readout_error(
        const std::vector<std::vector<double>>& readout_probabilities,
        const Qnum& qvec
        );
};

class QPanda::OptBMTQAllocator

Subgraph Isomorphism based Qubit Allocator. This QAllocator is split into 3 phases: 1.Partitions the program into a number of smaller programs, and find all* subgraph isomorphisms from the graph of that program to the coupling graph (architecture); 2.Dynamic programming that tests all combinations of subgraph isomorphisms, while estimating the cost of glueing themtogether; 3.Reconstructs the selected sequence of subgraph isomorphismsinto a program.

#include <OBMTQMapping.h>

class OptBMTQAllocator: public QPanda::AbstractQubitMapping
{
public:
    // typedefs

    typedef OptBMTQAllocator* Ref;
    typedef std::unique_ptr<OptBMTQAllocator> uRef;

    // fields

    std::vector<std::vector<double>> mCnotReliability;
    std::vector<std::vector<double>> mSwapDist;
    std::vector<double> mMeaReliability;
    double mCirReliability = 1.0;

    // methods

    static uRef Create(
        QPanda::ArchGraph::sRef ag,
        bool optimization = false,
        uint32_t max_partial = (std::numeric_limits<uint32_t>::max)(),
        uint32_t max_children = (std::numeric_limits<uint32_t>::max)()
        );

    static QPanda::ArchGraph::sRef build_arch_graph(const std::string& config_data = CONFIG_PATH);
    void setChildrenSelector(CandidateSelector::uRef sel);
};

Inherited Members

public:
    // typedefs

    typedef AbstractQubitMapping* Ref;
    typedef std::unique_ptr<AbstractQubitMapping> uRef;

    // methods

    bool run(QPanda::QProg prog, QPanda::QuantumMachine* qvm);
    void setGateWeightMap(const GateWeightMap& weightMap);
    const Mapping& get_final_mapping() const;
    const Mapping& get_init_mapping() const;
    QPanda::QProg get_mapped_prog() const;

template class QPanda::OracleBuilder

#include <Oracle.h>

template <class T>
class OracleBuilder
{
public:
    // construction

    OracleBuilder(
        const std::vector<T>& data_vec,
        ClassicalCondition condition,
        QuantumMachine* qvm
        );

    // methods

    QCircuit build_oracle_circuit(QCircuit cir_mark);
    const QVec& get_index_qubits();
    const QVec& get_oracle_qubits();
    const QVec& get_ancilla_qubits();
};

class QPanda::OriginCMemv2

Overview

#include <OriginQuantumMachine.h>

class OriginCMemv2: public QPanda::CMem
{
public:
    // construction

    OriginCMemv2(size_t maxMem);

    // methods

    virtual CBit* Allocate_CBit();
    virtual CBit* Allocate_CBit(size_t);
    virtual size_t getMaxMem() const;
    virtual size_t getIdleMem() const;
    virtual void Free_CBit(CBit*);
    virtual void clearAll();
    virtual size_t get_allocate_cbits(std::vector<CBit*>&);
};

Inherited Members

public:
    // methods

    virtual CBit* Allocate_CBit() = 0;
    virtual CBit* Allocate_CBit(size_t) = 0;
    virtual size_t getMaxMem() const = 0;
    virtual size_t getIdleMem() const = 0;
    virtual void Free_CBit(CBit*) = 0;
    virtual void clearAll() = 0;
    virtual size_t get_allocate_cbits(std::vector<CBit*>&) = 0;

Detailed Documentation

Methods

virtual CBit* Allocate_CBit()

allocate a CBit

Returns:

CBit*

virtual CBit* Allocate_CBit(size_t)

allocate a CBit by bit address

Returns:

CBit*

virtual size_t getMaxMem() const

get size of the CBit vector

Returns:

size_t

virtual size_t getIdleMem() const

get size of the idle position

Returns:

size_t

virtual void Free_CBit(CBit*)

free a CBit

Parameters:

CBit*

virtual void clearAll()

clear the CBit vector

virtual size_t get_allocate_cbits(std::vector<CBit*>&)

get allocate cbits

Parameters:

std::vector<CBit

*>&

Returns:

size_t allocate cbits size

class QPanda::OriginCollection

Overview

Origin Collection A relatively free data collection class for saving data. More…

#include <OriginCollection.h>

class OriginCollection
{
public:
    // construction

    OriginCollection();
    OriginCollection(const std::string& file_path, bool is_suffix = true);
    OriginCollection(const OriginCollection& old);

    // methods

    template <typename T>
    void addValue(const std::string& key_name, const T& value);

    template <typename T>
    void addValue(
        const std::string& key_name,
        const std::vector<T>& value
        );

    void addValue(const std::string& key_name, const std::vector<std::string>& value);
    void addValue(const std::string& key_name, const std::string& value);
    void addValue(const std::string& key_name, const char* value);
    void addValue(const std::string& key_name);
    OriginCollection& operator = (const std::initializer_list<std::string>& args);
    OriginCollection& operator = (const std::vector<std::string>& args);
    OriginCollection& operator = (const OriginCollection& old);

    template <typename T>
    void setValueByKey(
        const std::string& name,
        const std::initializer_list<T> args
        );

    void setValueByKey(const std::string& name, const std::initializer_list<std::string> args);
    void setValueByKey(const std::string& name, const std::initializer_list<const char*> args);

    template <typename T>
    void setValueByKey(
        const std::string& name,
        const std::vector<T>& value
        );

    template <class... ARG>
    void insertValue(const std::string& key, ARG... arg);

    template <class... ARG>
    void insertValue(const int key, ARG... arg);

    template <class... ARG>
    void insertValue(
        const std::vector<std::string>& name_vector,
        const std::string& key,
        ARG... args
        );

    template <class... ARG>
    void insertValue(
        const std::vector<std::string>& name_vector,
        const int key,
        ARG... args
        );

    std::vector<std::string> getValue(const std::string name);
    std::string getValueByKey(const std::string& key_value);
    std::string getValueByKey(int key_value);
    bool open(const std::string& file_name);
    bool write();
    std::string getJsonString();
    std::string getFilePath();
    std::vector<std::string> getKeyVector();
};

Detailed Documentation

Origin Collection A relatively free data collection class for saving data.

Parameters:

number

The num of key

Construction

OriginCollection()

Construct a new Origin Collection object.

OriginCollection(const std::string& file_path, bool is_suffix = true)

Construct a new Origin Collection Construct a new Origin Collection by file_path.

Parameters:

file_path

File path

OriginCollection(const OriginCollection& old)

Construct a new Origin Collection object by other Origin Collection.

Parameters:

old	target OriginCollection

Methods

template <typename T>
void addValue(const std::string& key_name, const T& value)

add value Assign a value to the specified key

Parameters:

T	value type
value_name	Key name
num	Key position in json
value	key value

template <typename T>
void addValue(
    const std::string& key_name,
    const std::vector<T>& value
    )

add value Assign a value to the specified key

Parameters:

T	value type
value_name	Key name
num	Key position in json
value	key value

void addValue(
    const std::string& key_name,
    const std::vector<std::string>& value
    )

add value Assign a value to the specified key

Parameters:

T	value type
value_name	Key name
num	Key position in json
value	key value

void addValue(const std::string& key_name, const std::string& value)

add value Set the value corresponding to the key

Parameters:

value_name	Key name
num	Key position in json
value	Key value

void addValue(const std::string& key_name, const char* value)

add value Set the value corresponding to the key

Parameters:

value_name	Key name
num	Key position in json
value	Key value

OriginCollection& operator = (const std::initializer_list<std::string>& args)

operator= Set the key of the object

Parameters:

args	arg list Key list

Returns:

OriginCollection &

OriginCollection& operator = (const std::vector<std::string>& args)

operator= Set the key of the object

Parameters:

args	arg list Key list

Returns:

OriginCollection &

OriginCollection& operator = (const OriginCollection& old)

operator= by other OriginCollection

Parameters:

old	target OriginCollection

Returns:

OriginCollection &

template <typename T>
void setValueByKey(
    const std::string& name,
    const std::initializer_list<T> args
    )

Set the Value set value list by key.

Parameters:

T	args type
name	key name
args	value array

void setValueByKey(
    const std::string& name,
    const std::initializer_list<std::string> args
    )

Set the Value set value list by key.

Parameters:

name	key name
args	value array

void setValueByKey(
    const std::string& name,
    const std::initializer_list<const char*> args
    )

Set the Value set value list by key.

Parameters:

name	key name
args	value array

template <typename T>
void setValueByKey(
    const std::string& name,
    const std::vector<T>& value
    )

Set the Value set vector<T> value by key.

Parameters:

T	args type
name	key name
args	value array

template <class... ARG>
void insertValue(const std::string& key, ARG... arg)

insert value Set the value of other properties by the value of the primary key

Parameters:

ARG	Variable length parameter tparam
key	Key value
arg	the value of other properties

template <class... ARG>
void insertValue(const int key, ARG... arg)

insert value Set the value of other properties by the value of the primary key

Parameters:

ARG	Variable length parameter tparam
key	Key value
arg	the value of other properties

std::vector<std::string> getValue(const std::string name)

Get value by Key.

Parameters:

name

Key name

Returns:

std::vector<std::string> value vector

std::string getValueByKey(const std::string& key_value)

Get value by primary Key value.

Parameters:

key_value

primary Key value

Returns:

std::string

std::string getValueByKey(int key_value)

Get value by primary Key value.

Parameters:

key_value

primary Key value

Returns:

std::string

bool open(const std::string& file_name)

open Read the json file of the specified path

Parameters:

file_name

file path

Returns:

true open success

false open fail

bool write()

write Write json file

Returns:

true Write success

false Write fail

std::string getJsonString()

Get the Json String Get object json string.

Returns:

std::string

std::string getFilePath()

Get the File Path.

Returns:

std::string

class QPanda::OriginMeasure

Overview

Qrigin quantum measure basic class. More…

#include <QuantumMeasure.h>

class OriginMeasure:
    public QPanda::QNode,
    public QPanda::AbstractQuantumMeasure
{
public:
    // construction

    OriginMeasure(
        Qubit*,
        CBit*
        );

    // methods

    virtual Qubit* getQuBit() const;
    virtual CBit* getCBit() const;
    virtual NodeType getNodeType() const;
};

Inherited Members

public:
    // methods

    virtual NodeType getNodeType() const = 0;
    virtual Qubit* getQuBit() const = 0;
    virtual CBit* getCBit() const = 0;

Detailed Documentation

Qrigin quantum measure basic class.

Methods

virtual Qubit* getQuBit() const

Get measure node qubit address.

Returns:

QPanda::Qubit * QuBit address

virtual CBit* getCBit() const

Get measure node cbit address.

Returns:

QPanda::CBit * cBit address

virtual NodeType getNodeType() const

Get current node type.

Returns:

NodeType current node type

See also:

NodeType

class QPanda::OriginQubitPool

Overview

#include <OriginQuantumMachine.h>

class OriginQubitPool: public QPanda::QubitPool
{
public:
    // methods

    static OriginQubitPool* get_instance();
    size_t get_capacity();
    void set_capacity(size_t);
    Qubit* get_qubit_by_addr(size_t qaddr);
    virtual void clearAll();
    virtual size_t getMaxQubit() const;
    virtual size_t getIdleQubit() const;
    virtual size_t get_max_usedqubit_addr() const;
    virtual Qubit* allocateQubit();
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t qubit_num);
    virtual void Free_Qubit(Qubit*);
    virtual size_t getPhysicalQubitAddr(Qubit*);
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual size_t get_allocate_qubits(std::vector<Qubit*>&) const;
    Qubit* qAlloc();
    QVec qAllocMany(size_t);
    void qFree(Qubit*);
    void qFreeAll(QVec&);
};

Inherited Members

public:
    // methods

    virtual size_t getMaxQubit() const = 0;
    virtual size_t get_max_usedqubit_addr() const = 0;
    virtual size_t getIdleQubit() const = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t qubit_num) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void clearAll() = 0;
    virtual size_t getPhysicalQubitAddr(Qubit*) = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual size_t get_allocate_qubits(std::vector<Qubit*>&) const = 0;

Detailed Documentation

Methods

virtual void clearAll()

clear the PhysicalQubit vector

virtual size_t getMaxQubit() const

get size of the PhysicalQubit vector

Returns:

size_t

virtual size_t getIdleQubit() const

get size of the idle position

Returns:

size_t

virtual size_t get_max_usedqubit_addr() const

Gets the largest address in the used physical qubit.

Returns:

size_t

virtual Qubit* allocateQubit()

allocate a Qubit

Returns:

Qubit*

virtual Qubit* allocateQubitThroughPhyAddress(size_t)

allocate a Qubit through physical address

Returns:

Qubit*

virtual Qubit* allocateQubitThroughVirAddress(size_t qubit_num)

allocate a Qubit through virtual address

Returns:

Qubit*

virtual void Free_Qubit(Qubit*)

free a Qubit

virtual size_t getPhysicalQubitAddr(Qubit*)

get physical qubit address

Parameters:

Qubit*

Returns:

size_t

virtual size_t getVirtualQubitAddress(Qubit*) const

get virtual qubit address

Parameters:

Qubit*

Returns:

size_t

virtual size_t get_allocate_qubits(std::vector<Qubit*>&) const

get allocate qubits

Parameters:

QVec&

Returns:

size_t

class QPanda::ParseExpressionStr

struct QPanda::ParseExpressionStr::StrNode

struct StrNode
{
    // fields

    std::string m_str;
    ListNodeT m_type;

    // construction

    StrNode(
        const std::string& str,
        ListNodeT t
        );
};

#include <PraseExpressionStr.h>

class ParseExpressionStr
{
public:
    // structs

    struct StrNode;

    // methods

    virtual double parse(const std::string& src_str);
};

class QPanda::PickUpNodes

Overview

Pick Up all the Nodes between the two NodeIters. More…

#include <QCircuitInfo.h>

class PickUpNodes: public QPanda::TraverseByNodeIter
{
public:
    // construction

    PickUpNodes(
        QProg& output_prog,
        QProg src_prog,
        const std::vector<NodeType>& reject_node_types,
        const NodeIter& node_itr_start,
        const NodeIter& node_itr_end
        );

    // methods

    virtual void traverse_qprog();

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    void setDaggerFlag(bool b);
    void reverse_dagger_circuit();
    static bool check_control_qubits(QGate& gate);
    static void no_dagger_gate(QGate& gate);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);

Detailed Documentation

Pick Up all the Nodes between the two NodeIters.

Construction

PickUpNodes(
    QProg& output_prog,
    QProg src_prog,
    const std::vector<NodeType>& reject_node_types,
    const NodeIter& node_itr_start,
    const NodeIter& node_itr_end
    )

Constructor of PickUpNodes.

Methods

void setDaggerFlag(bool b)

set dagger flag

Parameters:

bool

void reverse_dagger_circuit()

reverse the dagger circuit

static bool check_control_qubits(QGate& gate)

check whether the control qubit is same as the target qubit

Returns:

bool return true if the control qubit is same as the target qubit, otherwise return false

static void no_dagger_gate(QGate& gate)

check no dagger gate

class QPanda::ProcessOnTraversing

Overview

#include <ProcessOnTraversing.h>

class ProcessOnTraversing: protected QPanda::TraverseByNodeIter
{
public:
    // typedefs

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

    // methods

    virtual void process(const bool on_travel_end) = 0;

    virtual void run_traversal(
        QProg src_prog,
        const QVec qubits = {}
        );

    virtual void do_process(const bool on_travel_end);

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void gates_sink_to_topolog_sequence(
        OptimizerSink& gate_buf,
        LayeredTopoSeq& seq,
        const size_t max_output_layer = MAX_LAYER
        );

    virtual void clean_gate_buf_to_cir(QProg& cir, bool b_clean_all_buf = false);
    virtual void clean_gate_buf(bool b_clean_all_buf = false);
    virtual void drop_gates(const size_t max_drop_layer);

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

    virtual void seq_to_cir(
        layer_iter_seq& tmp_seq,
        QProg& prog
        );

    virtual void add_node_to_seq(
        layer_iter_seq& tmp_seq,
        NodeIter node_iter,
        const size_t layer
        );
};

// direct descendants

class QCircuitOPtimizer;

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);

Detailed Documentation

Methods

virtual void clean_gate_buf_to_cir(QProg& cir, bool b_clean_all_buf = false)

pop gate buf to circuit

Parameters:

QProg	& the output prog
bool	whether output all the gate node in gate buf

Returns:

class QPanda::QCirFragments

#include <CutQC.h>

class QCirFragments
{
public:
    // fields

    QCircuit m_cir;
    QVec m_prep_qubits;
    QVec m_meas_qubits;
    std::vector<FragmentResult> m_fragment_results;

    // construction

    QCirFragments(const SubCircuit& frag);
};

class QPanda::QCircuitGenerator

struct QPanda::QCircuitGenerator::CircuitNode

struct CircuitNode
{
    // fields

    std::string m_op;
    std::vector<uint32_t> m_target_q;
    std::vector<uint32_t> m_control_q;
    bool m_is_dagger;
    std::vector<std::string> m_angle;

    // construction

    CircuitNode();

    CircuitNode(
        std::string op,
        const std::vector<uint32_t>& target_q,
        const std::vector<std::string>& angle,
        const std::vector<uint32_t>& control_q,
        bool is_dagger
        );
};

#include <QCircuitGenerator.h>

class QCircuitGenerator
{
public:
    // typedefs

    typedef std::shared_ptr<QCircuitGenerator::CircuitNode> CircuitNodeRef;
    typedef std::shared_ptr<QCircuitGenerator> Ref;

    // structs

    struct CircuitNode;

    // methods

    void set_param(
        const QVec& qubits,
        const std::vector<double>& angle
        );

    CircuitNodeRef build_cir_node(
        std::string op,
        const std::vector<uint32_t>& target_q,
        const std::vector<std::string>& angle = {},
        const std::vector<uint32_t>& control_q = {},
        bool is_dagger = false
        );

    QCircuit get_cir();
    void append_cir_node(CircuitNodeRef node);

    void append_cir_node(
        std::string op,
        const std::vector<uint32_t>& target_q,
        const std::vector<std::string>& angle = {},
        const std::vector<uint32_t>& control_q = {},
        bool is_dagger = false
        );

    const std::vector<CircuitNodeRef>& get_cir_node_vec() const;
    uint32_t get_circuit_width();
    void set_circuit_width(uint32_t w);
};

class QPanda::QCircuitOPtimizer

Overview

#include <QCircuitOptimize.h>

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

    QProg m_new_prog;

    // methods

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

    void register_optimize_sub_cir(
        QCircuit sub_cir,
        QCircuit replase_to_cir
        );

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

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

Inherited Members

public:
    // typedefs

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

    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);
    virtual void process(const bool on_travel_end) = 0;
    virtual void run_traversal(QProg src_prog, const QVec qubits = {});
    virtual void do_process(const bool on_travel_end);

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

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

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

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

Detailed Documentation

Methods

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

replace sub circuit

Parameters:

std::function<QCircuit(const

size_t)> the function to get a new quantum circuit

Returns:

the new quantum prog

class QPanda::QCircuitOptimizerConfig

#include <JsonConfigParam.h>

class QCircuitOptimizerConfig
{
public:
    // construction

    QCircuitOptimizerConfig(const std::string config_data = CONFIG_PATH);

    // methods

    bool get_replace_cir(
        std::vector<std::pair<QCircuit, QCircuit>>& replace_cir_vec,
        std::string key_name = QCIRCUIT_OPTIMIZER
        );

    bool get_u3_replace_cir(std::vector<std::pair<QCircuit, QCircuit>>& replace_cir_vec);
};

class QPanda::QCircuitRewrite

struct QPanda::QCircuitRewrite::SemMatch

#include <QCircuitRewrite.h>

struct SemMatch
{
    // fields

    std::map<int, int> core_3;
    std::map<int, int> core_4;
    std::set<int> p_qubit_tobematched;
    std::set<int> g_qubit_tobematched;
    std::map<int, double> angle_map;
};

struct QPanda::QCircuitRewrite::StructMatch

#include <QCircuitRewrite.h>

struct StructMatch
{
    // fields

    std::map<int, int> core_1;
    std::map<int, int> core_2;
    std::set<int> T1_in;
    std::set<int> T1_out;
    std::set<int> T2_in;
    std::set<int> T2_out;
};

#include <QCircuitRewrite.h>

class QCircuitRewrite
{
public:
    // structs

    struct SemMatch;
    struct StructMatch;

    // fields

    StructMatch m_struct;
    SemMatch m_sem;
    std::set<int> matched;
    std::vector<std::map<int, int>> match_vertex_list;
    std::vector<std::map<int, int>> match_qubit_list;
    std::vector<std::map<int, double>> match_angle_list;

    // methods

    std::shared_ptr<QProgDAG> generator_to_dag(QCircuitGenerator& cir_gen);

    QProg replace_subgraph(
        std::shared_ptr<QProgDAG> g,
        QCircuitGenerator::Ref cir_gen
        );

    void recursiveMatch(
        std::shared_ptr<QProgDAG> pattern,
        std::shared_ptr<QProgDAG> graph,
        int i = 0
        );

    bool feasibilityRules(
        std::shared_ptr<QProgDAG> pattern,
        std::shared_ptr<QProgDAG> graph,
        int n,
        int m,
        StructMatch& match
        );

    std::shared_ptr<QProg> circuitRewrite(
        QProg prog,
        const std::string& config_data
        );

    static double angle_str_to_double(const std::string angle_str);
};

class QPanda::QCloudMachine

Overview

#include <QCloudMachine.h>

class QCloudMachine: public QPanda::QVM
{
public:
    // methods

    void init(std::string token);
    void set_compute_api(std::string url);
    void set_inqure_api(std::string url);

    void set_noise_model(
        NOISE_MODEL model,
        const std::vector<double> single_params,
        const std::vector<double> double_params
        );

    std::map<std::string, double> noise_measure(
        QProg&,
        int shot,
        std::string task_name = "Qurator Experiment"
        );

    std::map<std::string, double> full_amplitude_measure(
        QProg&,
        int shot,
        std::string task_name = "Qurator Experiment"
        );

    std::map<std::string, double> full_amplitude_pmeasure(
        QProg& prog,
        Qnum qubit_vec,
        std::string task_name = "Qurator Experiment"
        );

    std::map<std::string, qcomplex_t> partial_amplitude_pmeasure(
        QProg& prog,
        std::vector<std::string> amplitude_vec,
        std::string task_name = "Qurator Experiment"
        );

    qcomplex_t single_amplitude_pmeasure(QProg& prog, std::string amplitude, std::string task_name = "Qurator Experiment");

    std::map<std::string, double> real_chip_measure(
        QProg&,
        int shot,
        size_t chipid = 0,
        std::string task_name = "Qurator Experiment"
        );

    std::map<std::string, double> real_chip_task(
        QProg&,
        int shot,
        bool mapping_flag,
        bool circuit_optimization,
        bool is_vip,
        size_t chipid = 0
        );

    std::vector<QStat> get_state_tomography_density(QProg&, int shot, size_t chipid = 0);
    std::string get_result_json(std::string taskid, CLOUD_QMACHINE_TYPE type);
};

Inherited Members

public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {}) = 0;
    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {});
    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t);
    virtual QMachineStatus* getStatus() const;
    virtual QResult* getResult();
    virtual std::map<std::string, bool> getResultMap();
    virtual void finalize();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<int>&, int);
    virtual std::map<GateType, size_t> getGateTimeMap() const;
    virtual QStat getQState() const;
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*);
    virtual void set_random_engine(RandomEngine* rng);
    virtual void setConfig(const Configuration& config);
    virtual Qubit* allocateQubit();
    virtual QVec allocateQubits(size_t);
    virtual ClassicalCondition allocateCBit();
    virtual std::vector<ClassicalCondition> allocateCBits(size_t);
    virtual ClassicalCondition allocateCBit(size_t);
    virtual size_t getAllocateQubit();
    virtual size_t getAllocateCMem();
    virtual void Free_Qubit(Qubit*);
    virtual void Free_Qubits(QVec&);
    virtual void Free_CBit(ClassicalCondition&);
    virtual void Free_CBits(std::vector<ClassicalCondition>&);
    virtual void setConfigure(const Configuration&);
    virtual Qubit* qAlloc();
    virtual QVec qAllocMany(size_t qubit_count);
    virtual ClassicalCondition cAlloc();
    virtual ClassicalCondition cAlloc(size_t);
    virtual std::vector<ClassicalCondition> cAllocMany(size_t);
    virtual void qFree(Qubit*);
    virtual void qFreeAll(QVec&);
    virtual void cFree(ClassicalCondition&);
    virtual void cFreeAll(std::vector<ClassicalCondition>&);
    virtual size_t getAllocateQubitNum();
    virtual size_t getAllocateCMemNum();
    virtual size_t get_allocate_qubits(QVec&);
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int);

Detailed Documentation

Methods

void init(std::string token)

Init the quantum machine environment.

use this at the begin

Returns:

void

std::map<std::string, double> noise_measure(
    QProg&,
    int shot,
    std::string task_name = "Qurator Experiment"
    )

run a measure quantum program

Parameters:

QProg&	the reference to a quantum program
int&	shot
std::map<std::string
double>

Returns:

measure result

std::map<std::string, double> full_amplitude_measure(
    QProg&,
    int shot,
    std::string task_name = "Qurator Experiment"
    )

run a measure quantum program

Parameters:

QProg&	the reference to a quantum program
int&	shot
std::map<std::string
double>

Returns:

measure result

std::map<std::string, double> full_amplitude_pmeasure(
    QProg& prog,
    Qnum qubit_vec,
    std::string task_name = "Qurator Experiment"
    )

run a pmeasure quantum program

Parameters:

QProg&	the reference to a quantum program
Qnum	& qubit address vector
std::map<std::string
double>

Returns:

pmeasure result

std::map<std::string, qcomplex_t> partial_amplitude_pmeasure(
    QProg& prog,
    std::vector<std::string> amplitude_vec,
    std::string task_name = "Qurator Experiment"
    )

run a pmeasure quantum program with partial amplitude backend

Parameters:

QProg&	the reference to a quantum program
std::vector<std::string>	& amplitude subset
std::map<std::string
qcomplex_t>

Returns:

pmeasure result

qcomplex_t single_amplitude_pmeasure(
    QProg& prog,
    std::string amplitude,
    std::string task_name = "Qurator Experiment"
    )

run a pmeasure quantum program with single amplitude backend

Parameters:

QProg&	the reference to a quantum program
std::string	amplitude
qcomplex_t

Returns:

pmeasure result

std::map<std::string, double> real_chip_measure(
    QProg&,
    int shot,
    size_t chipid = 0,
    std::string task_name = "Qurator Experiment"
    )

run a measure quantum program

Parameters:

QProg&	the reference to a quantum program
int&	shot
std::map<std::string
double>

Returns:

measure result

std::map<std::string, double> real_chip_task(
    QProg&,
    int shot,
    bool mapping_flag,
    bool circuit_optimization,
    bool is_vip,
    size_t chipid = 0
    )

run a measure quantum program

Parameters:

QProg&	the reference to a quantum program
int&	shot
std::map<std::string
double>

Returns:

measure result

std::vector<QStat> get_state_tomography_density(QProg&, int shot, size_t chipid = 0)

get real chip qst matrix

Parameters:

QProg&	the reference to a quantum program
int&	shot
QStat	matrix

Returns:

matrix

std::string get_result_json(std::string taskid, CLOUD_QMACHINE_TYPE type)

get task result

Parameters:

std::string	taskid
CLOUD_QMACHINE_TYPE	type
std::string&	empty taskid

Returns:

string

class QPanda::QGateParseMap

#include <QGate.h>

class QGateParseMap
{
public:
    // methods

    static void insertMap(
        int opNum,
        QGATE_FUN function
        );

    static QGATE_FUN getFunction(int iOpNum);
};

class QPanda::QMachineStatus

#include <QuantumMachineInterface.h>

class QMachineStatus
{
public:
    // methods

    virtual int getStatusCode() const = 0;
    virtual void setStatusCode(int) = 0;
};

// direct descendants

class OriginQMachineStatus;

class QPanda::QNodeManager

#include <QNodeManager.h>

class QNodeManager
{
public:
    // construction

    QNodeManager(const QNode* parent);
    QNodeManager();

    // methods

    void push_back_node(std::shared_ptr<QNode> node);
    NodeIter get_first_node_iter();
    NodeIter get_last_node_iter();
    NodeIter get_end_node_iter();
    NodeIter get_head_node_iter();

    NodeIter insert_QNode(
        const NodeIter& perIter,
        std::shared_ptr<QNode> node
        );

    NodeIter delete_QNode(NodeIter& target_iter);
    void clear();
};

class QPanda::QObject

#include <QNode.h>

class QObject
{
};

// direct descendants

class QNode;

class QPanda::QPEAlg

#include <QPE.h>

class QPEAlg
{
public:
    // typedefs

    typedef std::function<QCircuit(QVec)> generate_cir_U;

    // construction

    QPEAlg(
        const QVec& control_qubits,
        const QVec& target_qubits,
        const QStat& matrix
        );

    QPEAlg(
        const QVec& control_qubits,
        const QVec& target_qubits,
        generate_cir_U cir_fun
        );

    // methods

    QCircuit QPE();
    QCircuit quantum_eigenvalue_estimation();
    QCircuit get_qpe_circuit();
};

class QPanda::QProgDAGVertex

#include <QProgDAG.h>

class QProgDAGVertex
{
public:
    // fields

    std::shared_ptr<QProgDAGNode> m_node;
    uint32_t m_id;
    DAGNodeType m_type;
    uint32_t m_layer;
    bool m_invalid;
    std::vector<uint32_t> m_pre_node;
    std::vector<uint32_t> m_succ_node;
    std::vector<QProgDAGEdge> m_pre_edges;
    std::vector<QProgDAGEdge> m_succ_edges;

    // methods

    bool is_pre_adjoin(const uint32_t& n);
    bool is_succ_adjoin(const uint32_t& n);
    void remove_pre_edge(const QProgDAGEdge& e);
    void remove_succ_edge(const QProgDAGEdge& e);
};

class QPanda::QProgToDAG

class QPanda::QProgToDAG::QCirParamForDAG

class QCirParamForDAG: public QPanda::QCircuitParam
{
public:
    // fields

    QProgDAG& m_dag;

    // construction

    QCirParamForDAG(QProgDAG& dag);

    // methods

    std::shared_ptr<QCircuitParam> clone();
};

Inherited Members

public:
    // fields

    bool m_is_dagger;
    QVec m_control_qubits;

    // methods

    virtual std::shared_ptr<QCircuitParam> clone();
    void append_control_qubits(const QVec& ctrl_qubits);
    static QVec get_real_append_qubits(QVec append_qubits, QVec target_qubits);

Overview

#include <QProgToDAG.h>

class QProgToDAG: protected QPanda::TraverseByNodeIter
{
public:
    // classes

    class QCirParamForDAG;

    // methods

    void traversal(QProg prog, QProgDAG& prog_dag);
};

Inherited Members

public:
    // methods

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        Args&&... func_args
        );

    virtual void execute(
        std::shared_ptr<AbstractQGateNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumMeasure> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumReset> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractClassicalProg> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractControlFlowNode> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumCircuit> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void execute(
        std::shared_ptr<AbstractQuantumProgram> cur_node,
        std::shared_ptr<QNode> parent_node,
        QCircuitParam& cir_param,
        NodeIter& cur_node_iter
        );

    virtual void traverse_qprog(QProg prog);

Detailed Documentation

Methods

void traversal(QProg prog, QProgDAG& prog_dag)

traversal QProg

Parameters:

_Ty&	node
QProgDAG&	prog_dag

Returns:

void

class QPanda::QVM

Overview

#include <OriginQuantumMachine.h>

class QVM: public QPanda::QuantumMachine
{
public:
    // methods

    virtual void initState(
        const QStat& state = {},
        const QVec& qlist = {}
        );

    virtual Qubit* allocateQubitThroughPhyAddress(size_t);
    virtual Qubit* allocateQubitThroughVirAddress(size_t);
    virtual QMachineStatus* getStatus() const;
    virtual QResult* getResult();
    virtual std::map<std::string, bool> getResultMap();
    virtual void finalize();
    virtual std::map<std::string, bool> directlyRun(QProg& qProg);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&);
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int);

    virtual std::map<std::string, size_t> runWithConfiguration(
        QProg&,
        std::vector<int>&,
        int
        );

    virtual std::map<GateType, size_t> getGateTimeMap() const;
    virtual QStat getQState() const;
    virtual size_t getVirtualQubitAddress(Qubit*) const;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*);
    virtual void set_random_engine(RandomEngine* rng);
    virtual void setConfig(const Configuration& config);
    virtual Qubit* allocateQubit();
    virtual QVec allocateQubits(size_t);
    virtual ClassicalCondition allocateCBit();
    virtual std::vector<ClassicalCondition> allocateCBits(size_t);
    virtual ClassicalCondition allocateCBit(size_t);
    virtual size_t getAllocateQubit();
    virtual size_t getAllocateCMem();
    virtual void Free_Qubit(Qubit*);
    virtual void Free_Qubits(QVec&);
    virtual void Free_CBit(ClassicalCondition&);
    virtual void Free_CBits(std::vector<ClassicalCondition>&);
    virtual void setConfigure(const Configuration&);
    virtual Qubit* qAlloc();
    virtual QVec qAllocMany(size_t qubit_count);
    virtual ClassicalCondition cAlloc();
    virtual ClassicalCondition cAlloc(size_t);
    virtual std::vector<ClassicalCondition> cAllocMany(size_t);
    virtual void qFree(Qubit*);
    virtual void qFreeAll(QVec&);
    virtual void cFree(ClassicalCondition&);
    virtual void cFreeAll(std::vector<ClassicalCondition>&);
    virtual size_t getAllocateQubitNum();
    virtual size_t getAllocateCMemNum();
    virtual size_t get_allocate_qubits(QVec&);
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&);
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int);

protected:
};

// direct descendants

class IdealQVM;
class NoiseQVM;
class PartialAmplitudeQVM;
class QCloudMachine;
class SingleAmplitudeQVM;

Inherited Members

public:
    // methods

    virtual Qubit* allocateQubitThroughPhyAddress(size_t) = 0;
    virtual Qubit* allocateQubitThroughVirAddress(size_t) = 0;
    virtual void init() = 0;
    virtual QMachineStatus* getStatus() const = 0;
    virtual std::map<std::string, bool> directlyRun(QProg& qProg) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, rapidjson::Document&) = 0;
    virtual std::map<std::string, size_t> runWithConfiguration(QProg&, std::vector<ClassicalCondition>&, int) = 0;
    virtual std::map<GateType, size_t> getGateTimeMap() const = 0;
    virtual void finalize() = 0;
    virtual QStat getQState() const = 0;
    virtual size_t getVirtualQubitAddress(Qubit*) const = 0;
    virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*) = 0;
    virtual void setConfig(const Configuration&) = 0;
    virtual Qubit* allocateQubit() = 0;
    virtual QVec allocateQubits(size_t) = 0;
    virtual ClassicalCondition allocateCBit() = 0;
    virtual ClassicalCondition allocateCBit(size_t) = 0;
    virtual std::vector<ClassicalCondition> allocateCBits(size_t) = 0;
    virtual void Free_Qubit(Qubit*) = 0;
    virtual void Free_Qubits(QVec&) = 0;
    virtual void Free_CBit(ClassicalCondition&) = 0;
    virtual void Free_CBits(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubit() = 0;
    virtual size_t getAllocateCMem() = 0;
    virtual void setConfigure(const Configuration&) = 0;
    virtual Qubit* qAlloc() = 0;
    virtual QVec qAllocMany(size_t qubit_count) = 0;
    virtual ClassicalCondition cAlloc() = 0;
    virtual ClassicalCondition cAlloc(size_t) = 0;
    virtual std::vector<ClassicalCondition> cAllocMany(size_t) = 0;
    virtual void qFree(Qubit*) = 0;
    virtual void qFreeAll(QVec&) = 0;
    virtual void cFree(ClassicalCondition&) = 0;
    virtual void cFreeAll(std::vector<ClassicalCondition>&) = 0;
    virtual size_t getAllocateQubitNum() = 0;
    virtual size_t getAllocateCMemNum() = 0;
    virtual void initState(const QStat& state = {}, const QVec& qlist = {}) = 0;
    virtual size_t get_allocate_qubits(QVec&) = 0;
    virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&) = 0;
    virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int) = 0;

Detailed Documentation

Methods

virtual Qubit* allocateQubitThroughPhyAddress(size_t)

allocateQubitThroughPhyAddress

Parameters:

size_t

address

Returns:

QPanda::Qubit * qubit

virtual Qubit* allocateQubitThroughVirAddress(size_t)

allocateQubitThroughVirAddress

Parameters:

size_t

address

Returns:

QPanda::Qubit * qubit

virtual QMachineStatus* getStatus() const

getStatus

Returns:

QPanda::QMachineStatus *

virtual void finalize()

finalize

Returns:

void

virtual std::map<std::string, bool> directlyRun(QProg& qProg)

directlyRun

Parameters:

QProg&

quantum program

Returns:

std::map<std::string, bool>

virtual std::map<std::string, size_t> runWithConfiguration(
    QProg&,
    std::vector<ClassicalCondition>&,
    rapidjson::Document&
    )

runWithConfiguration

Parameters:

QProg&	quantum program
std::vector<ClassicalCondition>&
rapidjson::Document&

Returns:

std::map<std::string, Eigen::size_t>

virtual std::map<std::string, size_t> runWithConfiguration(
    QProg&,
    std::vector<ClassicalCondition>&,
    int
    )

runWithConfiguration

Parameters:

QProg&	quantum program
std::vector<ClassicalCondition>&
int

Returns:

std::map<std::string, Eigen::size_t>

virtual std::map<GateType, size_t> getGateTimeMap() const

getGateTimeMap

Returns:

std::map<GateType, Eigen::size_t>

virtual QStat getQState() const

getQState

Returns:

QStat

virtual size_t getVirtualQubitAddress(Qubit*) const

getVirtualQubitAddress

Parameters:

Qubit*

qubit

Returns:

Eigen::size_t

virtual bool swapQubitPhysicalAddress(Qubit*, Qubit*)

swapQubitPhysicalAddress

Parameters:

Qubit*	qubit
Qubit*	qubit

Returns:

bool

virtual Qubit* allocateQubit()

To initialize the quantum machine.

virtual QVec allocateQubits(size_t)

Allocate and return a qubit.

virtual ClassicalCondition allocateCBit()

allocateQubits

virtual std::vector<ClassicalCondition> allocateCBits(size_t)

Allocate and run a cbit.

virtual ClassicalCondition allocateCBit(size_t)

Allocate and run a cbit.

virtual size_t getAllocateQubit()

Gree a list of CBits.

virtual size_t getAllocateCMem()

getAllocateQubit

virtual void Free_Qubit(Qubit*)

Allocate and return a list of cbits.

virtual void Free_Qubits(QVec&)

Free a qubit.

virtual void Free_CBit(ClassicalCondition&)

Gree a list of qubits.

virtual void Free_CBits(std::vector<ClassicalCondition>&)

Gree a cbit.

virtual void setConfigure(const Configuration&)

getAllocateCMem

setConfigure

Parameters:

const

Configuration & config

Returns:

void

virtual Qubit* qAlloc()

To initialize the quantum machine.

virtual QVec qAllocMany(size_t qubit_count)

Allocate and return a qubit.

virtual ClassicalCondition cAlloc()

allocateQubits

virtual ClassicalCondition cAlloc(size_t)

Allocate and run a cbit.

virtual std::vector<ClassicalCondition> cAllocMany(size_t)

Allocate and run a cbit.

virtual void qFree(Qubit*)

Allocate and return a list of cbits.

virtual void qFreeAll(QVec&)

Free a qubit.

virtual void cFree(ClassicalCondition&)

Gree a list of qubits.

virtual void cFreeAll(std::vector<ClassicalCondition>&)

Gree a cbit.

virtual size_t getAllocateQubitNum()

Gree a list of CBits.

virtual size_t getAllocateCMemNum()

getAllocateQubit

virtual size_t get_allocate_qubits(QVec&)

getAllocateCMem

virtual size_t get_allocate_cbits(std::vector<ClassicalCondition>&)

get allocate cbits

Parameters:

std::vector<ClassicalCondition>&

Returns:

size_t allocate cbits size

virtual double get_expectation(QProg, const QHamiltonian&, const QVec&)

gets the expected value of the Hamiltonian of the circuit

Parameters:

QProg	quantum program
QHamiltonian	hamiltonian
QVec	qubits

Returns:

double expectation

virtual double get_expectation(QProg, const QHamiltonian&, const QVec&, int)

gets the expected value of the Hamiltonian of the circuit

Parameters:

QProg	quantum program
QHamiltonian	hamiltonian
QVec	qubits
int	run shots

Returns:

double expectation

class QPanda::QWhileRegisterAction

Overview

QWhile program register action. More…

#include <ControlFlow.h>

class QWhileRegisterAction
{
public:
    // construction

    QWhileRegisterAction(
        std::string class_name,
        CreateQWhile_cb create_callback
        );
};

Detailed Documentation

QWhile program register action.

Provide QWhileFactory class registration interface for the outside

class QPanda::QuantumChipAdapter

#include <QuantumChipAdapter.h>

class QuantumChipAdapter
{
public:
    // construction

    QuantumChipAdapter(
        QuantumMachine* quantum_machine,
        bool b_mapping = true,
        const std::string config_data = CONFIG_PATH
        );

    // methods

    void init();

    void adapter_conversion(
        QProg& prog,
        QVec& new_qvec
        );

    void mapping(QProg& prog);
};

class QPanda::QuantumChipConfig

Overview

#include <JsonConfigParam.h>

class QuantumChipConfig
{
public:
    // methods

    bool load_config(const std::string config_data = CONFIG_PATH);

    bool read_adjacent_matrix(
        size_t& qubit_num,
        std::vector<std::vector<int>>& qubit_matrix
        );

    std::vector<int> read_high_frequency_qubit();
    std::vector<double> read_compensate_angle();
    void read_compensate_angle(std::map<std::pair<int, int>, std::vector<double>>&);
    size_t get_double_gate_clock(const size_t default_val = 3);
    size_t get_single_gate_clock(const size_t default_val = 1);
};

Detailed Documentation

Methods

bool load_config(const std::string config_data = CONFIG_PATH)

Load config data.

Parameters:

const

std::string It can be configuration file or configuration data, which can be distinguished by file suffix, so the configuration file must be end with “.json”, default is CONFIG_PATH

Returns:

Return false if any error occurs, otherwise return true

class QPanda::QuantumCircuitRegisterAction

Overview

QCircuit program register action. More…

#include <QCircuit.h>

class QuantumCircuitRegisterAction
{
public:
    // construction

    QuantumCircuitRegisterAction(
        std::string className,
        CreateQCircuit ptrCreateFn
        );
};

Detailed Documentation

QCircuit program register action.

Provide QuantumCircuitFactory class registration interface for the outside

class QPanda::QuantumCounting

#include <QuantumCounting.h>

class QuantumCounting: public QPanda::AbstractQuantumCounting
{
public:
    // construction

    QuantumCounting(
        QuantumMachine* qvm,
        QCircuit cir_oracle,
        QCircuit cir_diffusion,
        const QVec& data_index_qubits,
        const QVec& ancilla_qubits
        );

    // methods

    virtual size_t qu_counting();
    QProg build_qu_counting_prog();
    QCircuit QFT(std::vector<Qubit*> qvec);
    QCircuit QFTdagger(std::vector<Qubit*> qvec);
};

Inherited Members

public:
    // methods

    virtual size_t qu_counting() = 0;

class QPanda::QuantumMeasureRegisterAction

Overview

QMeasure program register action. More…

#include <QuantumMeasure.h>

class QuantumMeasureRegisterAction
{
public:
    // construction

    QuantumMeasureRegisterAction(
        std::string className,
        CreateMeasure ptrCreateFn
        );
};

Detailed Documentation

QMeasure program register action.

Provide QuantumMeasureFactory class registration interface for the outside

class QPanda::QuantumProgramRegisterAction

Overview

Quantum program register action. More…

#include <QProgram.h>

class QuantumProgramRegisterAction
{
public:
    // construction

    QuantumProgramRegisterAction(
        std::string className,
        CreateQProgram ptrCreateFn
        );
};

Detailed Documentation

Quantum program register action.

Provide QuantumProgramFactory class registration interface for the outside

class QPanda::QuantumResetRegisterAction

Overview

Quantum reset register action. More…

#include <QReset.h>

class QuantumResetRegisterAction
{
public:
    // construction

    QuantumResetRegisterAction(
        std::string className,
        CreateReset ptrCreateFn
        );
};

Detailed Documentation

Quantum reset register action.

Provide QResetFactory class registration interface for the outside

class QPanda::QubitAddr

#include <QuantumMachineInterface.h>

class QubitAddr
{
public:
    // construction

    QubitAddr(
        int ix,
        int iy
        );

    QubitAddr();

    // methods

    virtual int getX() const;
    virtual int getY() const;
    virtual void setX(int x);
    virtual void setY(int y);
};

class QPanda::QubitNodesSink

Overview

#include <ProcessOnTraversing.h>

class QubitNodesSink: public std::map< size_t, std::vector< pOptimizerNodeInfo > >
{
public:
    // typedefs

    typedef std::map<size_t, std::vector<pOptimizerNodeInfo>>::iterator QubitNodesSinkItr;
    typedef std::vector<pOptimizerNodeInfo>::iterator QubitNodesVecItr;

    // methods

    void append_data(
        pOptimizerNodeInfo p_node,
        const size_t qubit_i
        );

    void insert(GatesBufferType qubit_nodes);
    const size_t& get_target_qubit_sink_size(size_t q) const;
    size_t& get_target_qubit_sink_size(size_t q);
    SinkPos& get_sink_pos();
    void remove(size_t qubit, QubitNodesVecItr it_first, QubitNodesVecItr it_end);

    void remove(
        size_t qubit,
        QubitNodesVecItr it_first
        );
};

Detailed Documentation

Methods

void remove(size_t qubit, QubitNodesVecItr it_first, QubitNodesVecItr it_end)

note: not include it_end

class QPanda::RBGate

#include <RandomizedBenchmarking.h>

class RBGate
{
public:
    // methods

    virtual QGate qgate(Qubit* qbit) = 0;
    virtual QStat unitary() = 0;
};

class QPanda::RecombineFragment

Overview

#include <CutQC.h>

class RecombineFragment
{
public:
    // typedefs

    typedef Eigen::Matrix<qcomplex_t, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> cmatrix_t;
    typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> smatrix_t;
    typedef std::map<std::string, std::vector<std::pair<std::string, size_t>>> ResultDataMap;
    typedef std::vector<ResultDataMap> FragResultData;
};

Detailed Documentation

Typedefs

typedef std::vector<ResultDataMap> FragResultData

FragResultData:

class QPanda::ResultData

#include <CutQC.h>

class ResultData
{
public:
    // fields

    std::vector<PrepState> m_prep_labels;
    std::vector<MeasState> m_meas_labels;

    // construction

    ResultData(
        std::vector<PrepState> prep_labels,
        std::vector<MeasState> meas_labels
        );

    // methods

    bool operator < (const ResultData& data) const;
};

class QPanda::SabreQAllocator

SABRE qubit mapping Implemented from Gushu et. al.: Tackling the Qubit Mapping Problem for NISQ-Era Quantum Devices.

#include <SabreQMapping.h>

class SabreQAllocator: public QPanda::AbstractQubitMapping
{
public:
    // typedefs

    typedef SabreQAllocator* Ref;
    typedef std::unique_ptr<SabreQAllocator> uRef;

    // methods

    static uRef Create(
        QPanda::ArchGraph::sRef ag,
        uint32_t max_look_ahead = 20,
        uint32_t max_iterations = 10
        );

    uint32_t get_swap_cnt() const;
};

Inherited Members

public:
    // typedefs

    typedef AbstractQubitMapping* Ref;
    typedef std::unique_ptr<AbstractQubitMapping> uRef;

    // methods

    bool run(QPanda::QProg prog, QPanda::QuantumMachine* qvm);
    void setGateWeightMap(const GateWeightMap& weightMap);
    const Mapping& get_final_mapping() const;
    const Mapping& get_init_mapping() const;
    QPanda::QProg get_mapped_prog() const;

template class QPanda::SearchCondition

#include <SearchCondition.h>

template <class T>
class SearchCondition
{
public:
    // construction

    SearchCondition(
        QuantumMachine* qvm,
        ClassicalCondition condition
        );

    // methods

    void load_search_condition();

    QCircuit build_to_circuit(
        QVec oracle_qubits,
        QVec ancilla_qubits,
        const AbstractSearchData& mini_data,
        QCircuit cir_mark
        );
};

class QPanda::SearchDataByUInt

#include <SearchDataType.h>

class SearchDataByUInt: public QPanda::AbstractSearchData
{
public:
    // construction

    SearchDataByUInt(unsigned int val = 0);

    // methods

    virtual bool operator < (const AbstractSearchData& other) const;
    virtual bool operator <= (const AbstractSearchData& other) const;
    virtual bool operator > (const AbstractSearchData& other) const;
    virtual bool operator >= (const AbstractSearchData& other) const;
    virtual bool operator == (const AbstractSearchData&& other) const;
    virtual AbstractSearchData& operator - (const AbstractSearchData& other);
    SearchDataByUInt& operator = (const AbstractSearchData& other);
    virtual size_t check_max_need_qubits();
    virtual AbstractSearchData& set_val(const char* p_val);

    virtual QCircuit build_to_circuit(
        QVec& oracle_qubits,
        size_t use_qubit_cnt,
        const AbstractSearchData& mini_data
        ) const;

    virtual QCircuit build_to_condition_circuit(
        QVec& oracle_qubits,
        QCircuit cir_mark,
        const AbstractSearchData& mini_data
        );
};

Inherited Members

public:
    // methods

    virtual bool operator < (const AbstractSearchData& other) const = 0;
    virtual bool operator <= (const AbstractSearchData& other) const = 0;
    virtual bool operator > (const AbstractSearchData& other) const = 0;
    virtual bool operator >= (const AbstractSearchData& other) const = 0;
    virtual bool operator == (const AbstractSearchData&& other) const = 0;
    virtual AbstractSearchData& operator - (const AbstractSearchData& other) = 0;
    virtual QCircuit build_to_circuit(QVec& used_qubits, size_t use_qubit_cnt, const AbstractSearchData& mini_data) const = 0;
    virtual QCircuit build_to_condition_circuit(QVec& used_qubits, QCircuit cir_mark, const AbstractSearchData& mini_data) = 0;
    virtual size_t check_max_need_qubits() = 0;
    virtual AbstractSearchData& set_val(const char* p_val) = 0;

template class QPanda::SearchSpace

#include <SearchSpace.h>

template <class T>
class SearchSpace
{
public:
    // construction

    SearchSpace(
        QuantumMachine* qvm,
        ClassicalCondition condition
        );

    // methods

    const QVec& get_index_qubits();
    const QVec& get_data_qubits();
    QCircuit build_to_circuit(const std::vector<T>& data_vec);
    const AbstractSearchData& get_mini_data();
};

class QPanda::ShortestDistanceByBFS

Overview

Calculates the distance between two vertices by applying BFS. More…

#include <ShortestDistanceByBFS.h>

class ShortestDistanceByBFS
{
public:
    // typedefs

    typedef ShortestDistanceByBFS* Ref;
    typedef std::shared_ptr<ShortestDistanceByBFS> sRef;
    typedef std::unique_ptr<ShortestDistanceByBFS> uRef;
    typedef std::vector<uint32_t> VecUInt32;
    typedef std::vector<VecUInt32> MatrixUInt32;

    // methods

    void init(Graph::Ref graph);

    uint32_t get(
        uint32_t u,
        uint32_t v
        );

    static uRef create();
};

Detailed Documentation

Calculates the distance between two vertices by applying BFS.

Methods

static uRef create()

Instantiate one object of this type.

class QPanda::SimplifiedApproxTSFinder

Simplified 4-Approximative polynomial algorithm. Miltzow et al. DOI: 10.4230/LIPIcs.ESA.2016.66.

#include <TokenSwapFinder.h>

class SimplifiedApproxTSFinder: public QPanda::TokenSwapFinder
{
public:
    // typedefs

    typedef SimplifiedApproxTSFinder* Ref;
    typedef std::unique_ptr<SimplifiedApproxTSFinder> uRef;

    // methods

    static uRef Create();
};

Inherited Members

public:
    // typedefs

    typedef TokenSwapFinder* Ref;
    typedef std::unique_ptr<TokenSwapFinder> uRef;

    // methods

    void set_graph(QPanda::Graph::Ref graph);
    SwapSeq find(const InverseMap& from, const InverseMap& to);

class QPanda::TokenSwapFinder

#include <TokenSwapFinder.h>

class TokenSwapFinder
{
public:
    // typedefs

    typedef TokenSwapFinder* Ref;
    typedef std::unique_ptr<TokenSwapFinder> uRef;

    // methods

    void set_graph(QPanda::Graph::Ref graph);

    SwapSeq find(
        const InverseMap& from,
        const InverseMap& to
        );
};

// direct descendants

class ApproxTSFinder;
class SimplifiedApproxTSFinder;

template class QPanda::TopologSequence

#include <TopologSequence.h>

template <class T>
class TopologSequence: public std::vector< SeqLayer< T > >
{
public:
};

template class QPanda::WeightedGraph

#include <Graph.h>

template <typename T>
class WeightedGraph: public QPanda::Graph
{
public:
    // typedefs

    typedef WeightedGraph<T>* Ref;
    typedef std::unique_ptr<WeightedGraph<T>> uRef;
    typedef std::shared_ptr<WeightedGraph<T>> sRef;

    // construction

    WeightedGraph(
        uint32_t n,
        Type ty = Undirected
        );

    // methods

    void putEdge(
        uint32_t i,
        uint32_t j,
        T w
        );

    void setW(
        uint32_t i,
        uint32_t j,
        T w
        );

    T getW(
        uint32_t i,
        uint32_t j
        ) const;

    static bool ClassOf(const Graph* g);

    static uRef Create(
        uint32_t n,
        Type ty = Undirected
        );
};

// direct descendants

class ArchGraph;

Inherited Members

public:
    // typedefs

    typedef Graph* Ref;
    typedef std::unique_ptr<Graph> uRef;
    typedef std::shared_ptr<Graph> sRef;

    // enums

    enum Kind;
    enum Type;

    // methods

    uint32_t inDegree(uint32_t i) const;
    uint32_t outDegree(uint32_t i) const;
    uint32_t size() const;
    std::set<uint32_t>& succ(uint32_t i);
    const std::set<uint32_t>& c_succ(uint32_t i) const;
    std::set<uint32_t>& pred(uint32_t i);
    std::set<uint32_t> adj(uint32_t i) const;
    void putEdge(uint32_t i, uint32_t j);
    bool hasEdge(uint32_t i, uint32_t j) const;
    bool isWeighted() const;
    bool isArch() const;
    bool isDirectedGraph() const;
    std::string dotify(std::string name = "Dump") const;
    static bool ClassOf(const Graph* g);
    static uRef Create(uint32_t n, Type ty = Undirected);

class QPanda::calloc_fail

#include <QPandaException.h>

class calloc_fail: public QPanda::QPandaException
{
public:
    // construction

    calloc_fail();
    calloc_fail(std::string errmsg);
};

Inherited Members

public:
    // methods

    virtual const char* what();

class QPanda::gate_alloc_fail

#include <QPandaException.h>

class gate_alloc_fail: public QPanda::QPandaException
{
public:
    // construction

    gate_alloc_fail();
    gate_alloc_fail(std::string err);
};

Inherited Members

public:
    // methods

    virtual const char* what();

class QPanda::threadPool

Overview

#include <ThreadPool.h>

class threadPool
{
public:
    // methods

    bool init_thread_pool(size_t thread_cnt = DEFAULT_THREAD_CNT);
    bool append(Task task);
};

Detailed Documentation

Methods

bool init_thread_pool(size_t thread_cnt = DEFAULT_THREAD_CNT)

init thread pool

Parameters:

size_t

Number of threads in the thread pool, 8 by default

Returns:

void

Overview

namespace QPanda {

// namespaces

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

// typedefs

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

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

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

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

typedef AbstractQuantumCircuit* (*CreateQCircuit)();

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

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

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

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

// enums

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

// structs

template <typename T>
struct CNodeCandidate;

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

template <>
struct JsonBackendParser<ArchGraph>;

template <class T>
struct JsonBackendParser;

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

template <>
struct JsonBackendParser<Graph>;

template <>
struct JsonFields<ArchGraph>;

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

template <>
struct JsonFields<Graph>;

template <class T>
struct JsonFields;

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

// classes

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

template <class T>
class FermionOp;

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

template <class T>
class JsonParser;

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

template <class T>
class OracleBuilder;

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

template <class T>
class PauliOp;

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

template <class T>
class SearchCondition;

class SearchDataByUInt;

template <class T>
class SearchSpace;

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

template <class T>
class TopologSequence;

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

template <typename... Args>
class TraversalInterface;

class TraverseByNodeIter;
class UncompletedGridDevice;

template <typename T>
class WeightedGraph;

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

// global variables

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

// global functions

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

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

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

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

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

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

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

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

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

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

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

prob_tuple PMeasure(
    QVec qubit_vector,
    int select_max
    );

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

QIfProg CreateIfProg(
    ClassicalCondition classical_condition,
    QProg true_node
    );

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

QWhileProg CreateWhileProg(
    ClassicalCondition,
    QProg trueNode
    );

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

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

QGate copy_qgate(
    QuantumGate* qgate_old,
    QVec qubit_vector
    );

QGate copy_qgate(
    QGate& qgate,
    QVec qubit_vector
    );

QGate copy_qgate(
    QGate* qgate,
    QVec qubit_vector
    );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

size_t get_all_used_qubits(
    QProg prog,
    QVec& vecQuBitsInUse
    );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string draw_qprog(
    QProg prog,
    LayeredTopoSeq& m_layer_info,
    uint32_t length = 100,
    bool b_out_put_to_file = false
    );

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

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

} // namespace QPanda

Detailed Documentation

Typedefs

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

typedef MetadataValidity_cb that add all functions of metadata validity

Global Variables

const int kInfinite = 0xffff

Int infinite.

const int kError = -1

Error identifier.

Global Functions

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

BravyiKitaev transform from FermionOperator to PauliOperator.

Parameters:

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

Returns:

PauliOperator

See also:

FermionOperator

PauliOperator

ClassicalCondition operator + (cbit_size_t value, ClassicalCondition class_cond)

Overload operator +.

Parameters:

value	cbit_size_t type left operand
class_cond	ClassicalCondition type right operand

Returns:

ClassicalCondition

ClassicalCondition operator + (ClassicalCondition left_operand, ClassicalCondition right_operand)

Uverload operator +.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator + (ClassicalCondition left_operand, cbit_size_t right_operand)

Overload operator +.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator - (ClassicalCondition left_operand, ClassicalCondition right_operand)

Overload operator -.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator - (ClassicalCondition left_operand, cbit_size_t right_operand)

Overload operator -.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator - (cbit_size_t value, ClassicalCondition class_cond)

Overload operator -.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator * (ClassicalCondition, ClassicalCondition)

Overload operator *.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator * (ClassicalCondition, cbit_size_t)

Overload operator *.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator * (cbit_size_t value, ClassicalCondition class_cond)

Overload operator -.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator/ (ClassicalCondition, ClassicalCondition)

Overload operator /.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator/ (ClassicalCondition, cbit_size_t)

Overload operator /.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator/ (cbit_size_t value, ClassicalCondition class_cond)

Overload operator /.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator == (ClassicalCondition, ClassicalCondition)

Overload operator ==.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator == (ClassicalCondition, cbit_size_t)

Overload operator ==.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator == (cbit_size_t value, ClassicalCondition class_cond)

Overload operator ==.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator != (ClassicalCondition, ClassicalCondition)

Overload operator !=.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator != (ClassicalCondition, cbit_size_t)

Overload operator !=.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator != (cbit_size_t value, ClassicalCondition classical_cond)

Overload operator !=.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator && (ClassicalCondition, ClassicalCondition)

Overload operator &&.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator && (ClassicalCondition, cbit_size_t)

Overload operator &&.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator && (cbit_size_t value, ClassicalCondition classical_cond)

Overload operator &&.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator|| (ClassicalCondition, ClassicalCondition)

Overload operator ||.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator|| (ClassicalCondition, cbit_size_t)

Overload operator ||.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator|| (cbit_size_t value, ClassicalCondition classical_cond)

Overload operator ||.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator > (ClassicalCondition, ClassicalCondition)

Overload operator >

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator > (ClassicalCondition, cbit_size_t)

Overload operator >

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator > (cbit_size_t value, ClassicalCondition class_cond)

Overload operator >

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator >= (ClassicalCondition, ClassicalCondition)

Overload operator >=.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator >= (ClassicalCondition, cbit_size_t)

Overload operator >=.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator >= (cbit_size_t value, ClassicalCondition class_cond)

Overload operator >=.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator < (ClassicalCondition, ClassicalCondition)

Overload operator <.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator < (ClassicalCondition, cbit_size_t)

Overload operator <.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator < (cbit_size_t value, ClassicalCondition class_cond)

Overload operator <.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator <= (ClassicalCondition, ClassicalCondition)

Overload operator <=.

Parameters:

left_operand	left operand
right_operand	right operand

Returns:

ClassicalCondition

ClassicalCondition operator <= (ClassicalCondition, cbit_size_t)

Overload operator <=.

Parameters:

left_operand	left operand
right_operand	cbit_size_t type right operand

Returns:

ClassicalCondition

ClassicalCondition operator <= (cbit_size_t value, ClassicalCondition class_cond)

Overload operator <=.

Parameters:

value	cbit_size_t type left operand
class_cond	right operand

Returns:

ClassicalCondition

ClassicalCondition operator ! (ClassicalCondition)

Overload operator !

Parameters:

right_operand

right operand

Returns:

ClassicalCondition

QGate iSWAP(Qubit* targitBit_fisrt, Qubit* targitBit_second)

Construct a new quantum iSWAP gate.

Parameters:

Qubit*	control qubit
Qubit*	target qubit

Returns:

QPanda::QGate quantum gate

QGate iSWAP(int control_qaddr, int target_qaddr)

Construct a new quantum iSWAP gate.

Parameters:

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

Returns:

QPanda::QGate quantum gate

Qubit* get_qubit_by_phyaddr(int qaddr)

Get Qubit by physics addr.

Parameters:

int	qaddr target qubit phy addr

Returns:

Qubit*

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

Get Qubit vector by physics addr vector.

Parameters:

const

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

Returns:

Qubit*

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

calculate double gate xeb

Parameters:

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

Returns:

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

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

calculate double gate xeb

Parameters:

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

Returns:

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

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

Judge whether the prog is related to the target qubits.

Parameters:

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

Returns:

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

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

Verify the validity of double quantum gates.

Parameters:

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

Returns:

int double quantum gate type

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

Count quantum program unsupported gate numner.

Parameters:

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

Returns:

size_t Unsupported QGate number

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

calculate quantum volume

Parameters:

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

Returns:

size_t quantum volume

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

calculate quantum volume

Parameters:

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

Returns:

size_t quantum volume

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

single gate rb experiment

Parameters:

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

Returns:

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

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

single gate rb experiment

Parameters:

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

Returns:

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

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

single gate rb experiment

Parameters:

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

Returns:

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

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

single gate rb experiment

Parameters:

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

Returns:

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

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

convert unicode string to UTF8 string

Parameters:

std::wstring&

the source wstring encoded by Unicode

Returns:

string Converted String

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

convert UTF8 string to wide string

Parameters:

std::string&

the source string

Returns:

wstring Converted wide String

std::string ulongToUtf8(unsigned long val)

convert unsigned long to string

Parameters:

unsigned long

the source val

Returns:

std::string Converted string

void initConsole()

set windows console to utf-8 encode

namespace gpu

namespace gpu {

// global functions

__global__ void unitarysingle(
    gpu_qstate_t* psireal,
    gpu_qstate_t* psiimag,
    gpu_qsize_t Dim,
    gpu_qsize_t Block,
    gpu_qstate_t matrix_real00,
    gpu_qstate_t matrix_real01,
    gpu_qstate_t matrix_real10,
    gpu_qstate_t matrix_real11,
    gpu_qstate_t matrix_imag00,
    gpu_qstate_t matrix_imag01,
    gpu_qstate_t matrix_imag10,
    gpu_qstate_t matrix_imag11
    );

__global__ void controlunitarysingle(
    gpu_qstate_t* psireal,
    gpu_qstate_t* psiimag,
    gpu_qsize_t Dim,
    gpu_qsize_t target_qubit,
    gpu_qsize_t controller_mask,
    gpu_qstate_t matrix_real00,
    gpu_qstate_t matrix_real01,
    gpu_qstate_t matrix_real10,
    gpu_qstate_t matrix_real11,
    gpu_qstate_t matrix_imag00,
    gpu_qstate_t matrix_imag01,
    gpu_qstate_t matrix_imag10,
    gpu_qstate_t matrix_imag11
    );

__global__ void unitarydouble(
    gpu_qstate_t* psireal,
    gpu_qstate_t* psiimag,
    gpu_qsize_t Dim,
    gpu_qsize_t Block1,
    gpu_qsize_t Block2,
    gpu_qstate_t real0000,
    gpu_qstate_t real0001,
    gpu_qstate_t real0010,
    gpu_qstate_t real0011,
    gpu_qstate_t real0100,
    gpu_qstate_t real0101,
    gpu_qstate_t real0110,
    gpu_qstate_t real0111,
    gpu_qstate_t real1000,
    gpu_qstate_t real1001,
    gpu_qstate_t real1010,
    gpu_qstate_t real1011,
    gpu_qstate_t real1100,
    gpu_qstate_t real1101,
    gpu_qstate_t real1110,
    gpu_qstate_t real1111,
    gpu_qstate_t imag0000,
    gpu_qstate_t imag0001,
    gpu_qstate_t imag0010,
    gpu_qstate_t imag0011,
    gpu_qstate_t imag0100,
    gpu_qstate_t imag0101,
    gpu_qstate_t imag0110,
    gpu_qstate_t imag0111,
    gpu_qstate_t imag1000,
    gpu_qstate_t imag1001,
    gpu_qstate_t imag1010,
    gpu_qstate_t imag1011,
    gpu_qstate_t imag1100,
    gpu_qstate_t imag1101,
    gpu_qstate_t imag1110,
    gpu_qstate_t imag1111
    );

__global__ void controlunitarydouble(
    gpu_qstate_t* psireal,
    gpu_qstate_t* psiimag,
    gpu_qsize_t Dim,
    gpu_qsize_t controller_mask,
    gpu_qsize_t control_qubit,
    gpu_qsize_t target_qubit,
    gpu_qstate_t real0000,
    gpu_qstate_t real0001,
    gpu_qstate_t real0010,
    gpu_qstate_t real0011,
    gpu_qstate_t real0100,
    gpu_qstate_t real0101,
    gpu_qstate_t real0110,
    gpu_qstate_t real0111,
    gpu_qstate_t real1000,
    gpu_qstate_t real1001,
    gpu_qstate_t real1010,
    gpu_qstate_t real1011,
    gpu_qstate_t real1100,
    gpu_qstate_t real1101,
    gpu_qstate_t real1110,
    gpu_qstate_t real1111,
    gpu_qstate_t imag0000,
    gpu_qstate_t imag0001,
    gpu_qstate_t imag0010,
    gpu_qstate_t imag0011,
    gpu_qstate_t imag0100,
    gpu_qstate_t imag0101,
    gpu_qstate_t imag0110,
    gpu_qstate_t imag0111,
    gpu_qstate_t imag1000,
    gpu_qstate_t imag1001,
    gpu_qstate_t imag1010,
    gpu_qstate_t imag1011,
    gpu_qstate_t imag1100,
    gpu_qstate_t imag1101,
    gpu_qstate_t imag1110,
    gpu_qstate_t imag1111
    );

__global__ void initState(
    gpu_qstate_t* psireal,
    gpu_qstate_t* psiimag,
    gpu_qsize_t Dim
    );

__global__ void qubitprob(
    gpu_qstate_t* psireal,
    gpu_qstate_t* psiimag,
    gpu_qsize_t Dim,
    gpu_qsize_t Block,
    gpu_qstate_t* pr
    );

__global__ void probsum(
    gpu_qstate_t* pr,
    gpu_qstate_t* prob
    );

__global__ void qubitcollapse0(
    gpu_qstate_t* psireal,
    gpu_qstate_t* psiimag,
    gpu_qsize_t Dim,
    gpu_qsize_t Block,
    gpu_qstate_t coef
    );

__global__ void qubitcollapse1(
    gpu_qstate_t* psireal,
    gpu_qstate_t* psiimag,
    gpu_qsize_t Dim,
    gpu_qsize_t Block,
    gpu_qstate_t coef
    );

__global__ void multiprob(
    gpu_qstate_t* psireal,
    gpu_qstate_t* psiimag,
    gpu_qsize_t Dim,
    gpu_qstate_t* pro,
    gpu_qsize_t* block,
    gpu_qsize_t m,
    gpu_qsize_t dec
    );

__global__ void probsumnew1(
    gpu_qstate_t* psireal,
    gpu_qstate_t* psiimag,
    gpu_qstate_t* probtemp,
    size_t num1,
    size_t m,
    size_t Dim,
    size_t* block
    );

__global__ void pmeasure_many_target(
    gpu_qstate_t* psireal,
    gpu_qstate_t* psiimag,
    double* result,
    gpu_qsize_t qnum_mask,
    gpu_qsize_t result_size,
    gpu_qsize_t Dim
    );

__global__ void pmeasure_one_target(
    gpu_qstate_t* psireal,
    gpu_qstate_t* psiimag,
    double* result,
    gpu_qsize_t qnum_mask,
    size_t result_idx,
    gpu_qsize_t result_dim,
    gpu_qsize_t Dim
    );

double randGenerator();

} // namespace gpu

namespace std

template struct std::hash<QPanda::Variational::var>

hash function to enable unordered_map<var, _Ty> and unordered_set **

#include <var.h>

template <>
struct hash<QPanda::Variational::var>
{
    // methods

    size_t operator () (const QPanda::Variational::var&) const;
};

namespace std {

// structs

template <>
struct hash<QPanda::Variational::var>;

} // namespace std

enum ComputeBackend

#include <Tensor.h>

enum ComputeBackend
{
    CPU,
};

enum GateType

Overview

#include <QGlobalVariable.h>

enum GateType
{
    GATE_UNDEFINED   = -1,
    P0_GATE,
    P1_GATE,
    PAULI_X_GATE,
    PAULI_Y_GATE,
    PAULI_Z_GATE,
    X_HALF_PI,
    Y_HALF_PI,
    Z_HALF_PI,
    HADAMARD_GATE,
    T_GATE,
    S_GATE,
    RX_GATE,
    RY_GATE,
    RZ_GATE,
    RPHI_GATE,
    U1_GATE,
    U2_GATE,
    U3_GATE,
    U4_GATE,
    CU_GATE,
    CNOT_GATE,
    CZ_GATE,
    CPHASE_GATE,
    ISWAP_THETA_GATE,
    ISWAP_GATE,
    SQISWAP_GATE,
    SWAP_GATE,
    TWO_QUBIT_GATE,
    P00_GATE,
    P11_GATE,
    TOFFOLI_GATE,
    ORACLE_GATE,
    I_GATE,
    ECHO_GATE,
    BARRIER_GATE,
};

Detailed Documentation

Enum Values

P0_GATE

Quantum p0 gate

P1_GATE

Quantum p1 gate

PAULI_X_GATE

Quantum pauli x gate

PAULI_Y_GATE

Quantum pauli y gate

PAULI_Z_GATE

Quantum pauli z gate

X_HALF_PI

Quantum x half gate

Y_HALF_PI

Quantum y half gate

Z_HALF_PI

Quantum z half gate

HADAMARD_GATE

Quantum hadamard gate

T_GATE

Quantum t gate

S_GATE

Quantum s gate

RX_GATE

Quantum rotation x gate

RY_GATE

Quantum rotation y gate

RZ_GATE

Quantum rotation z gate

U1_GATE

Quantum u1 gate

U2_GATE

Quantum u2 gate

U3_GATE

Quantum u3 gate

U4_GATE

Quantum u4 gate

CU_GATE

Quantum control-u gate

CNOT_GATE

Quantum control-not gate

CZ_GATE

Quantum control-z gate

CPHASE_GATE

Quantum control-rotation gate

ISWAP_THETA_GATE

Quantum iswap-theta gate

ISWAP_GATE

Quantum iswap gate

SQISWAP_GATE

Quantum sqiswap gate

SWAP_GATE

Quantum swap gate

TWO_QUBIT_GATE

Quantum two-qubit gate

ECHO_GATE

Only for 6 qubit online projects

BARRIER_GATE

Only for 6 qubit online projects

enum MetadataGateType

Overview

#include <QGlobalVariable.h>

enum MetadataGateType
{
    METADATA_SINGLE_GATE,
    METADATA_DOUBLE_GATE,
};

Detailed Documentation

Enum Values

METADATA_SINGLE_GATE

Metadata single gate

METADATA_DOUBLE_GATE

Metadata double gate

enum NOISE_MODEL

noise model type

#include <NoiseModel.h>

enum NOISE_MODEL
{
    DAMPING_KRAUS_OPERATOR,
    DEPHASING_KRAUS_OPERATOR,
    DECOHERENCE_KRAUS_OPERATOR_P1_P2,
    BITFLIP_KRAUS_OPERATOR,
    DEPOLARIZING_KRAUS_OPERATOR,
    BIT_PHASE_FLIP_OPRATOR,
    PHASE_DAMPING_OPRATOR,
    DECOHERENCE_KRAUS_OPERATOR,
    PAULI_KRAUS_MAP,
    KRAUS_MATRIX_OPRATOR,
    MIXED_UNITARY_OPRATOR,
};

enum NodeType

Overview

#include <QGlobalVariable.h>

enum NodeType
{
    NODE_UNDEFINED   = -1,
    GATE_NODE,
    CIRCUIT_NODE,
    PROG_NODE,
    MEASURE_GATE,
    WHILE_START_NODE,
    QIF_START_NODE,
    CLASS_COND_NODE,
    QWAIT_NODE,
    RESET_NODE,
};

Detailed Documentation

Enum Values

NODE_UNDEFINED

Undefined node

GATE_NODE

Quantum gate node

CIRCUIT_NODE

Quantum circuit node

PROG_NODE

Quantum program node

MEASURE_GATE

Quantum measure node

WHILE_START_NODE

Quantum while controlflow start node

QIF_START_NODE

Quantum if controlflow start node

CLASS_COND_NODE

Quantum classical condition node

QWAIT_NODE

QWait node

RESET_NODE

QReset node

enum OperatorType

#include <QGlobalVariable.h>

enum OperatorType
{
    TYPE_OPERATOR_NODE,
    TYPE_CBIT_NODE,
    TYPE_CINT_NODE,
};

enum QError

Overview

#include <QError.h>

enum QError
{
    qErrorNone          = 2,
    undefineError,
    qParameterError,
    qubitError,
    loadFileError,
    initStateError,
    destroyStateError,
    setComputeUnitError,
    runProgramError,
    getResultError,
    getQStateError,
};

Detailed Documentation

Enum Values

qErrorNone

no error

undefineError

undefined error

qParameterError

wrong parameter

qubitError

qubits error not only numbers

loadFileError

load file failed

initStateError

init quantum state error

destroyStateError

destroy state error

setComputeUnitError

set compute unit error

runProgramError

quantum program running time error

getResultError

get result error

getQStateError

get quantum state error

struct Complex

#include <GPUStruct.h>

struct Complex
{
    // fields

    gpu_qstate_t real;
    gpu_qstate_t imag;
};

struct QGateParam

#include <QuantumGateParameter.h>

struct QGateParam
{
    // fields

    Qnum qVec;
    QStat qstate;
    int qubitnumber;
    bool enable = true;

    // construction

    QGateParam();
    QGateParam(int qn);

    QGateParam(
        int qn,
        Qnum num
        );
};

struct QubitVertice

#include <TensorNode.h>

struct QubitVertice
{
    // fields

    qsize_t m_qubit_id {SIZE_MAX};
    qsize_t m_num {SIZE_MAX};
    qsize_t m_max {SIZE_MAX};
    qsize_t m_count {SIZE_MAX};
};

class AbstractComplexTensor

#include <Tensor.h>

class AbstractComplexTensor
{
public:
    // methods

    virtual size_t getRank() const = 0;
    virtual size_t getMaxRank() const = 0;
    virtual qcomplex_data_t getElem(size_t num) = 0;
    virtual void dimIncrement(size_t) = 0;

    virtual void getSubTensor(
        size_t num,
        int value
        ) = 0;

    virtual void dimDecrement(size_t num) = 0;
    virtual qcomplex_data_t* getTensor() = 0;

    virtual void mul(
        ComplexTensor& other,
        size_t* mask_array
        ) = 0;

    virtual ComputeBackend getBackend() = 0;
};

// direct descendants

class ComplexTensor;
class CPUComplexTensor;

class CPUComplexTensor

#include <Tensor.h>

class CPUComplexTensor: public AbstractComplexTensor
{
public:
    // construction

    CPUComplexTensor(const CPUComplexTensor& old);

    CPUComplexTensor(
        size_t rank,
        qstate_t& tensor,
        size_t max_rank
        );

    CPUComplexTensor(
        size_t rank,
        qcomplex_data_t* tensor,
        size_t max_rank
        );

    // methods

    virtual size_t getRank() const;
    virtual qcomplex_data_t getElem(size_t num);
    virtual size_t getMaxRank() const;
    virtual void dimIncrement(size_t increment_size);

    virtual void getSubTensor(
        size_t num,
        int value
        );

    virtual void dimDecrement(size_t num);
    virtual qcomplex_data_t* getTensor();

    virtual void mul(
        ComplexTensor& other,
        size_t* mask_array
        );

    virtual ComputeBackend getBackend();

    void mulElem(
        size_t num,
        qcomplex_data_t elem
        );

    CPUComplexTensor& operator = (const CPUComplexTensor& old);
};

Inherited Members

public:
    // methods

    virtual size_t getRank() const = 0;
    virtual size_t getMaxRank() const = 0;
    virtual qcomplex_data_t getElem(size_t num) = 0;
    virtual void dimIncrement(size_t) = 0;
    virtual void getSubTensor(size_t num, int value) = 0;
    virtual void dimDecrement(size_t num) = 0;
    virtual qcomplex_data_t* getTensor() = 0;
    virtual void mul(ComplexTensor& other, size_t* mask_array) = 0;
    virtual ComputeBackend getBackend() = 0;

class CPUImplQPUSingleThread

Overview

#include <CPUImplQPUSingleThread.h>

class CPUImplQPUSingleThread: public QPUImpl
{
public:
    // fields

    vQParam qubit2stat;
    vQParam init_qubit2stat;

    // construction

    CPUImplQPUSingleThread();
    CPUImplQPUSingleThread(size_t);

    // methods

    QGateParam& findgroup(size_t qn);

    bool TensorProduct(
        QGateParam& qgroup0,
        QGateParam& qgroup1
        );

    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType);
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType);
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);

    virtual QError P0(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError P0(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError P1(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError P1(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError Hadamard(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError Hadamard(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError X(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError X(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError Y(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError Y(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError Z(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError Z(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError T(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError T(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError S(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    virtual QError S(
        size_t qn,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError U1_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError RX_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError RX_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError RY_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError RY_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError RZ_GATE(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError RZ_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError CNOT(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    virtual QError CNOT(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError CR(
        size_t qn_0,
        size_t qn_1,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError CR(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError CZ(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    virtual QError CZ(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError SqiSWAP(
        size_t qn_0,
        size_t qn_1,
        bool isConjugate,
        double error_rate
        );

    virtual QError SqiSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError DiagonalGate(
        Qnum& vQubit,
        QStat& matrix,
        bool isConjugate,
        double error_rate
        );

    virtual QError controlDiagonalGate(
        Qnum& vQubit,
        QStat& matrix,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QStat getQState();
    virtual QError Reset(size_t qn);
    virtual bool qubitMeasure(size_t qn);

    QError pMeasure(
        Qnum& qnum,
        prob_tuple& mResult,
        int select_max = -1
        );

    virtual QError pMeasure(
        Qnum& qnum,
        prob_vec& mResult
        );

    virtual QError initState(
        size_t head_rank,
        size_t rank_size,
        size_t qubit_num
        );

    virtual QError initState(
        size_t qubit_num,
        const QStat& state = {}
        );
};

// direct descendants

class CPUImplQPUSingleThreadWithOracle;

Inherited Members

public:
    // methods

    virtual bool qubitMeasure(size_t qn) = 0;
    virtual QError pMeasure(Qnum& qnum, prob_vec& mResult) = 0;
    virtual QError initState(size_t head_rank, size_t rank_size, size_t qubit_num) = 0;
    virtual QError initState(size_t qubit_num, const QStat& state = {}) = 0;
    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QStat getQState() = 0;
    virtual void set_random_engine(RandomEngine* rng);
    virtual double get_random_double();
    virtual QError Reset(size_t qn) = 0;

Detailed Documentation

Methods

virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType)

unitary single qubit gate

Parameters:

size_t	qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitarySingleQubitGate(
    size_t qn,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

controlunitary single qubit gate

Parameters:

size_t	qubit address
Qnum&	control qubit addresses
QStat	& matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError unitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

unitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
QStat&	matrix
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QError controlunitaryDoubleQubitGate(
    size_t qn_0,
    size_t qn_1,
    Qnum& qnum,
    QStat& matrix,
    bool isConjugate,
    GateType
    )

controlunitary double qubit gate

Parameters:

size_t	first qubit address
size_t	second qubit address
Qnum&	control qubit addresses
QStat&	quantum states
bool	state of conjugate
GateType	gate type

Returns:

QError

virtual QStat getQState()

get quantum states

virtual QError Reset(size_t qn)

reset qubit

Parameters:

size_t

qubit address

class CPUImplQPUSingleThreadWithOracle

#include <CPUImplQPUSingleThread.h>

class CPUImplQPUSingleThreadWithOracle: public CPUImplQPUSingleThread
{
public:
    // methods

    QError controlOracularGate(
        std::vector<size_t> bits,
        std::vector<size_t> controlbits,
        bool is_dagger,
        std::string name
        );
};

Inherited Members

public:
    // fields

    vQParam qubit2stat;
    vQParam init_qubit2stat;

    // methods

    virtual bool qubitMeasure(size_t qn) = 0;
    virtual QError pMeasure(Qnum& qnum, prob_vec& mResult) = 0;
    virtual QError initState(size_t head_rank, size_t rank_size, size_t qubit_num) = 0;
    virtual QError initState(size_t qubit_num, const QStat& state = {}) = 0;
    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QStat getQState() = 0;
    virtual void set_random_engine(RandomEngine* rng);
    virtual double get_random_double();
    virtual QError Reset(size_t qn) = 0;
    QGateParam& findgroup(size_t qn);
    bool TensorProduct(QGateParam& qgroup0, QGateParam& qgroup1);
    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType);
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType);
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    virtual QError P0(size_t qn, bool isConjugate, double error_rate);
    virtual QError P0(size_t qn, Qnum& vControlBit, bool isConjugate, double error_rate);
    virtual QError P1(size_t qn, bool isConjugate, double error_rate);
    virtual QError P1(size_t qn, Qnum& vControlBit, bool isConjugate, double error_rate);
    virtual QError Hadamard(size_t qn, bool isConjugate, double error_rate);
    virtual QError Hadamard(size_t qn, Qnum& vControlBit, bool isConjugate, double error_rate);
    virtual QError X(size_t qn, bool isConjugate, double error_rate);
    virtual QError X(size_t qn, Qnum& vControlBit, bool isConjugate, double error_rate);
    virtual QError Y(size_t qn, bool isConjugate, double error_rate);
    virtual QError Y(size_t qn, Qnum& vControlBit, bool isConjugate, double error_rate);
    virtual QError Z(size_t qn, bool isConjugate, double error_rate);
    virtual QError Z(size_t qn, Qnum& vControlBit, bool isConjugate, double error_rate);
    virtual QError T(size_t qn, bool isConjugate, double error_rate);
    virtual QError T(size_t qn, Qnum& vControlBit, bool isConjugate, double error_rate);
    virtual QError S(size_t qn, bool isConjugate, double error_rate);
    virtual QError S(size_t qn, Qnum& vControlBit, bool isConjugate, double error_rate);
    virtual QError U1_GATE(size_t qn, double theta, bool isConjugate, double error_rate);
    virtual QError RX_GATE(size_t qn, double theta, bool isConjugate, double error_rate);

    virtual QError RX_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError RY_GATE(size_t qn, double theta, bool isConjugate, double error_rate);

    virtual QError RY_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError RZ_GATE(size_t qn, double theta, bool isConjugate, double error_rate);

    virtual QError RZ_GATE(
        size_t qn,
        double theta,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError CNOT(size_t qn_0, size_t qn_1, bool isConjugate, double error_rate);

    virtual QError CNOT(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError CR(
        size_t qn_0,
        size_t qn_1,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError CR(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError CZ(size_t qn_0, size_t qn_1, bool isConjugate, double error_rate);

    virtual QError CZ(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double error_rate
        );

    virtual QError iSWAP(size_t qn_0, size_t qn_1, bool isConjugate, double error_rate);

    virtual QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError SqiSWAP(size_t qn_0, size_t qn_1, bool isConjugate, double error_rate);

    virtual QError SqiSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QError DiagonalGate(Qnum& vQubit, QStat& matrix, bool isConjugate, double error_rate);

    virtual QError controlDiagonalGate(
        Qnum& vQubit,
        QStat& matrix,
        Qnum& vControlBit,
        bool isConjugate,
        double error_rate
        );

    virtual QStat getQState();
    virtual QError Reset(size_t qn);
    virtual bool qubitMeasure(size_t qn);
    QError pMeasure(Qnum& qnum, prob_tuple& mResult, int select_max = -1);
    virtual QError pMeasure(Qnum& qnum, prob_vec& mResult);
    virtual QError initState(size_t head_rank, size_t rank_size, size_t qubit_num);
    virtual QError initState(size_t qubit_num, const QStat& state = {});

class CPUImplQPUWithOracle

#include <CPUImplQPU.h>

class CPUImplQPUWithOracle: public CPUImplQPU
{
public:
    // methods

    QError controlOracularGate(
        std::vector<size_t> bits,
        std::vector<size_t> controlbits,
        bool is_dagger,
        std::string name
        );
};

Inherited Members

public:
    // fields

    vQParam qubit2stat;
    vQParam init_qubit2stat;

    // methods

    virtual bool qubitMeasure(size_t qn) = 0;
    virtual QError pMeasure(Qnum& qnum, prob_vec& mResult) = 0;
    virtual QError initState(size_t head_rank, size_t rank_size, size_t qubit_num) = 0;
    virtual QError initState(size_t qubit_num, const QStat& state = {}) = 0;
    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType) = 0;
    virtual QStat getQState() = 0;
    virtual void set_random_engine(RandomEngine* rng);
    virtual double get_random_double();
    virtual QError Reset(size_t qn) = 0;
    QGateParam& findgroup(size_t qn);
    bool TensorProduct(QGateParam& qgroup0, QGateParam& qgroup1);

    template <
        const qcomplex_t& U00,
        const qcomplex_t& U01,
        const qcomplex_t& U10,
        const qcomplex_t& U11
        >
    QError single_gate(
        size_t qn,
        bool isConjugate,
        double error_rate
        );

    QError U1_GATE(size_t qn, double theta, bool isConjugate, double error_rate);

    template <const double& Nx, const double& Ny, const double& Nz>
    QError single_angle_gate(
        size_t qn,
        double theta,
        bool isConjugate,
        double error_rate
        );

    template <const double& Nx, const double& Ny, const double& Nz>
    QError control_single_angle_gate(
        size_t qn,
        double theta,
        Qnum vControlBit,
        bool isConjugate,
        double error_rate
        );

    template <
        const qcomplex_t& U00,
        const qcomplex_t& U01,
        const qcomplex_t& U10,
        const qcomplex_t& U11
        >
    QError control_single_gate(
        size_t qn,
        Qnum vControlBit,
        bool isConjugate,
        double error_rate
        );

    CONST_GATE(P0);
    CONST_GATE(P1);
    CONST_GATE(X);
    CONST_GATE(Y);
    CONST_GATE(Z);
    CONST_GATE(Hadamard);
    CONST_GATE(T);
    CONST_GATE(S);
    SINGLE_ANGLE_GATE(RX_GATE);
    SINGLE_ANGLE_GATE(RY_GATE);
    SINGLE_ANGLE_GATE(RZ_GATE);
    CONTROL_SINGLE_ANGLE_GATE(RX_GATE);
    CONTROL_SINGLE_ANGLE_GATE(RY_GATE);
    CONTROL_SINGLE_ANGLE_GATE(RZ_GATE);
    CONTROL_CONST_GATE(Hadamard);
    CONTROL_CONST_GATE(X);
    CONTROL_CONST_GATE(Y);
    CONTROL_CONST_GATE(Z);
    CONTROL_CONST_GATE(T);
    CONTROL_CONST_GATE(S);
    CONTROL_CONST_GATE(P0);
    CONTROL_CONST_GATE(P1);
    QError CNOT(size_t qn_0, size_t qn_1, bool isConjugate, double error_rate);
    QError CNOT(size_t qn_0, size_t qn_1, Qnum& vControlBit, bool isConjugate, double error_rate);
    QError iSWAP(size_t qn_0, size_t qn_1, double theta, bool isConjugate, double);

    QError iSWAP(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double
        );

    QError iSWAP(size_t qn_0, size_t qn_1, bool isConjugate, double error_rate);
    QError iSWAP(size_t qn_0, size_t qn_1, Qnum& vControlBit, bool isConjugate, double error_rate);
    QError SqiSWAP(size_t qn_0, size_t qn_1, bool isConjugate, double error_rate);
    QError SqiSWAP(size_t qn_0, size_t qn_1, Qnum& vControlBit, bool isConjugate, double error_rate);
    QError CR(size_t qn_0, size_t qn_1, double theta, bool isConjugate, double error_rate);

    QError CR(
        size_t qn_0,
        size_t qn_1,
        Qnum& vControlBit,
        double theta,
        bool isConjugate,
        double error_rate
        );

    QError CZ(size_t qn_0, size_t qn_1, bool isConjugate, double error_rate);
    QError CZ(size_t qn_0, size_t qn_1, Qnum& vControlBit, bool isConjugate, double error_rate);
    virtual QError unitarySingleQubitGate(size_t qn, QStat& matrix, bool isConjugate, GateType);
    virtual QError controlunitarySingleQubitGate(size_t qn, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    virtual QError unitaryDoubleQubitGate(size_t qn_0, size_t qn_1, QStat& matrix, bool isConjugate, GateType);
    virtual QError controlunitaryDoubleQubitGate(size_t qn_0, size_t qn_1, Qnum& qnum, QStat& matrix, bool isConjugate, GateType);
    QError DiagonalGate(Qnum& vQubit, QStat& matrix, bool isConjugate, double error_rate);
    QError controlDiagonalGate(Qnum& vQubit, QStat& matrix, Qnum& vControlBit, bool isConjugate, double error_rate);
    virtual QStat getQState();
    virtual QError Reset(size_t qn);
    virtual bool qubitMeasure(size_t qn);
    QError pMeasure(Qnum& qnum, prob_tuple& mResult, int select_max = -1);
    virtual QError pMeasure(Qnum& qnum, prob_vec& mResult);
    virtual QError initState(size_t head_rank, size_t rank_size, size_t qubit_num);
    virtual QError initState(size_t qubit_num, const QStat& state = {});
    QError P00(size_t qn_0, size_t qn_1, bool isConjugate, double error_rate);
    QError SWAP(size_t qn_0, size_t qn_1, bool isConjugate, double error_rate);
    QError P11(size_t qn_0, size_t qn_1, bool isConjugate, double error_rate);

class ComplexTensor

#include <Tensor.h>

class ComplexTensor: public AbstractComplexTensor
{
public:
    // construction

    ComplexTensor(std::shared_ptr<AbstractComplexTensor> tensor);
    ComplexTensor(const ComplexTensor& old);

    ComplexTensor(
        ComputeBackend backend,
        size_t rank,
        qstate_t& tensor,
        size_t max_rank
        );

    ComplexTensor(
        ComputeBackend backend,
        size_t rank,
        qcomplex_data_t* tensor,
        size_t max_rank
        );

    // methods

    virtual size_t getRank() const;
    virtual qcomplex_data_t getElem(size_t num);
    virtual void dimIncrement(size_t num);

    virtual void getSubTensor(
        size_t num,
        int value
        );

    virtual void dimDecrement(size_t num);
    virtual qcomplex_data_t* getTensor();

    virtual void mul(
        ComplexTensor& other,
        size_t* mask_array
        );

    virtual size_t getMaxRank() const;
    virtual ComputeBackend getBackend();
    ComplexTensor& operator = (const ComplexTensor& old);
};

Inherited Members

public:
    // methods

    virtual size_t getRank() const = 0;
    virtual size_t getMaxRank() const = 0;
    virtual qcomplex_data_t getElem(size_t num) = 0;
    virtual void dimIncrement(size_t) = 0;
    virtual void getSubTensor(size_t num, int value) = 0;
    virtual void dimDecrement(size_t num) = 0;
    virtual qcomplex_data_t* getTensor() = 0;
    virtual void mul(ComplexTensor& other, size_t* mask_array) = 0;
    virtual ComputeBackend getBackend() = 0;

class Edge

#include <TensorNode.h>

class Edge
{
public:
    // construction

    Edge(
        qsize_t qubit_count,
        ComplexTensor& tensor,
        std::vector<std::pair<qsize_t, qsize_t>>& contect_vertice
        );

    // methods

    void earseContectVertice(
        qsize_t qubit,
        size_t num
        );

    qsize_t getQubitCount() const;
    bool mergeEdge(Edge& edge);

    void dimDecrementbyValue(
        qsize_t qubit,
        qsize_t num,
        int value
        );

    void dimDecrement(
        qsize_t qubit,
        qsize_t num
        );

    void dimIncrementByEdge(Edge& edge);

    void getEdgeMap(
        Edge& edge,
        size_t* mask
        );

    void mul(
        Edge& edge,
        size_t* mask_array
        );

    int getRank() const;
    ComplexTensor getComplexTensor() const;
    qcomplex_data_t getElem(VerticeMatrix& vertice);
    void setComplexTensor(ComplexTensor& tensor);
    void getContectVertice(std::vector<std::pair<qsize_t, qsize_t>>& connect_vertice) const;
    void setContectVerticeVector(const qubit_vector_t& contect_vertice);

    void setContectVertice(
        qsize_t qubit,
        qsize_t src_num,
        qsize_t des_num
        );
};

class Instructions

#include <instructions.h>

class Instructions
{
public:
    // methods

    static Instructions* getInstance();
};

class MPS_Tensor

#include <MPSTensor.h>

class MPS_Tensor
{
public:
    // fields

    std::vector<cmatrix_t> m_physical_index;

    // construction

    MPS_Tensor();

    MPS_Tensor(
        const cmatrix_t& data0,
        const cmatrix_t& data1
        );

    // methods

    size_t get_dim() const;
    std::vector<cmatrix_t> get_data() const;
    cmatrix_t get_data(size_t i) const;
    void apply_swap();

    void apply_matrix(
        const cmatrix_t& mat,
        bool swapped = false
        );

    void mul_gamma_by_left_lambda(const rvector_t& Lambda);
    void mul_gamma_by_right_lambda(const rvector_t& Lambda);
    void div_gamma_by_left_lambda(const rvector_t& Lambda);
    void div_gamma_by_right_lambda(const rvector_t& Lambda);
    void apply_pauli(GateType gate);

    static MPS_Tensor contract(
        const MPS_Tensor& left_gamma,
        const rvector_t& lambda,
        const MPS_Tensor& right_gamma
        );

    static void decompose(
        MPS_Tensor& temp,
        MPS_Tensor& left_gamma,
        rvector_t& lambda,
        MPS_Tensor& right_gamma
        );

    static void contract_2_dimensions(
        const MPS_Tensor& left_gamma,
        const MPS_Tensor& right_gamma,
        cmatrix_t& result
        );
};

class MeasureQVMType

calibrated machine type

class NoisyQuantum

#include <NoiseModel.h>

class NoisyQuantum
{
public:
    // typedefs

    typedef std::map<std::string, size_t> qubit_quantum_error_map_t;
    typedef std::map<GateType, qubit_quantum_error_map_t> gate_noisy_map_t;

    // methods

    bool sample_noisy_op(
        GateType type,
        const Qnum& qns,
        NOISE_MODEL& model,
        NoiseOp& ops,
        Qnum& effect_qubits,
        RandomEngine19937& rng
        );

    bool sample_noisy_op(
        GateType type,
        const Qnum& qns,
        NoiseOp& ops,
        Qnum& effect_qubits,
        RandomEngine19937& rng
        );

    bool sample_noisy_op(
        size_t qn,
        std::vector<std::vector<double>>& readout,
        RandomEngine19937& rng
        );

    void add_quamtum_error(
        GateType type,
        const QuantumError& quantum_error,
        const QuantumError::noise_qubits_t& noise_qubits = {}
        );
};

class QProgMap

#include <TensorNode.h>

class QProgMap
{
public:
    // fields

    size_t m_count {0};

    // construction

    QProgMap();
    QProgMap(const QProgMap& old);

    // methods

    size_t getMaxRank();
    size_t setMaxRank(size_t rank);
    void deleteMap();
    QProgMap& operator = (const QProgMap& old);
    VerticeMatrix* getVerticeMatrix();
    size_t getQubitVerticeCount(qsize_t qubit_num);
    void setQubitNum(size_t num);
    bool isEmptyQProg();
    size_t getQubitNum();
    edge_map_t* getEdgeMap();
    void clearVerticeValue();
    void clear();
    qsize_t getVerticeCount() const;
};

class QuantumError

#include <NoiseModel.h>

class QuantumError
{
public:
    // typedefs

    typedef std::vector<std::vector<size_t>> noise_qubits_t;

    // construction

    QuantumError();

    QuantumError(
        const NOISE_MODEL& model,
        double prob,
        size_t qubit_num
        );

    // methods

    void set_noise(
        const NOISE_MODEL& model,
        double prob,
        size_t qubit_num
        );

    void set_noise(
        const NOISE_MODEL& model,
        double T1,
        double T2,
        double t_gate,
        size_t qubit_num
        );

    void set_noise(
        const NOISE_MODEL& model,
        const std::vector<QStat>& unitary_matrices,
        const std::vector<double>& probs,
        size_t qubit_num
        );

    void set_noise(
        const NOISE_MODEL& model,
        const std::vector<QStat>& unitary_matrices,
        size_t qubit_num
        );

    void set_reset_error(
        double p0,
        double p1
        );

    void set_readout_error(
        const std::vector<std::vector<double>>& probs_list,
        size_t qubit_num
        );

    bool sample_noise(
        NOISE_MODEL& model,
        NoiseOp& noise_ops,
        Qnum& noise_qubits,
        RandomEngine19937& rng
        );

    bool sample_noise(
        NoiseOp& noise_ops,
        Qnum& noise_qubits,
        RandomEngine19937& rng
        );

    bool sample_readout(std::vector<std::vector<double>>& readout);
    void set_qubit_num(int num);
    int get_qubit_num() const;
    bool _optimize_ops(NoiseOp& ops);
    NOISE_MODEL get_noise_model();
};

class QuickBB

class QuickBB::Graph

#include <QuickBB.h>

class Graph
{
public:
    // methods

    const adj_arr_t& get_neighborhood(vertex_index_t nodeIndex) const;
    auto begin() const;
    auto end() const;
    void remove_vertex(vertex_index_t vertexIndex);

    bool has_edge(
        vertex_index_t u,
        vertex_index_t v
        ) const;

    bool add_edge(
        vertex_index_t u,
        vertex_index_t v
        );

    bool remove_edge(
        vertex_index_t u,
        vertex_index_t v
        );

    void contract_edge(
        vertex_index_t u,
        vertex_index_t v
        );

    vertex_index_t degree(vertex_index_t nodeIndex) const;
    vertex_index_t order() const;
};

Overview

#include <QuickBB.h>

class QuickBB
{
public:
    // classes

    class Graph;

    // methods

    static std::pair<size_t, adj_arr_t> compute(Graph& graph, size_t alloted_time);

    static std::pair<size_t, adj_arr_t> compute(
        const std::vector<std::pair<size_t, size_t>>& vertice_vect,
        size_t alloted_time
        );

    static void make_clique(
        Graph& graph,
        const adj_arr_t& vertices
        );

    static bool is_clique(
        const Graph& graph,
        const adj_arr_t& vertices
        );

    static bool simplicial(
        const Graph& graph,
        vertex_index_t vertex
        );

    static bool almost_simplicial(
        const Graph& graph,
        vertex_index_t vertex
        );

    static void eliminate(
        Graph& graph,
        vertex_index_t vertex
        );

    static size_t count_fillin(
        const Graph& graph,
        adj_arr_t vertices
        );

    static std::pair<adj_arr_t, size_t> upper_bound(const Graph& graph);
    static size_t lower_bound(const Graph& graph);
};

Detailed Documentation

Methods

static std::pair<size_t, adj_arr_t> compute(Graph& graph, size_t alloted_time)

compute the optimal order

Parameters:

Graph	QuickBB graph
size_t	alloted compute time

Returns:

std::pair<size_t, adj_arr_t> first : tree width , second : order

static std::pair<size_t, adj_arr_t> compute(
    const std::vector<std::pair<size_t, size_t>>& vertice_vect,
    size_t alloted_time
    )

compute the optimal order

Parameters:

std::vector<std::pair<size_t
size_t>>	QuickBB graph
size_t	alloted compute time

Returns:

std::pair<size_t, adj_arr_t> first : tree width , second : order

class RandomEngine19937

#include <RandomEngine.h>

class RandomEngine19937
{
public:
    // methods

    void set_random_seed();
    void set_random_seed(size_t seed);

    double random_double(
        double a = 0.,
        double b = 1.
        );

    template <typename Float = double>
    int random_discrete(const std::vector<Float>& probs);
};

class TensorEngine

#include <TensorEngine.h>

class TensorEngine
{
public:
    // methods

    static void split(
        QProgMap& prog_map,
        qubit_vertice_t& qubit_vertice
        );

    static qubit_vertice_t getNoValueVertice(
        QProgMap& prog_map,
        size_t contect_edge
        );

    static qubit_vertice_t getNoValueAndContectEdgeMaxVertice(QProgMap& prog_map);

    static qcomplex_data_t Merge(
        QProgMap& prog_map,
        const qprog_sequence_t& sequence
        );

    static qcomplex_data_t computing(QProgMap& prog_map);

    static std::map<qsize_t, Vertice>::iterator MergeQuantumProgMap(
        QProgMap&,
        qubit_vertice_t&,
        bool& is_success
        );

    static void MergeByVerticeVector(
        QProgMap&,
        qprog_sequence_t& sequence
        );

    static void dimDecrementbyValue(
        QProgMap&,
        qubit_vertice_t&,
        int value
        );

    static void dimDecrementbyValueAndNum(
        QProgMap&,
        qubit_vertice_t&,
        int value
        );

    static void getVerticeMap(
        QProgMap&,
        std::vector<std::pair<size_t, size_t>>&
        );

    static size_t getMaxRank(QProgMap&);
    static qubit_vertice_t getMaxQubitVertice(QProgMap& prog_map);

    static void seq_merge_by_vertices(
        QProgMap& prog_map,
        std::vector<size_t> vertice_vector,
        qprog_sequence_t& sequence
        );

    static void seq_merge(
        QProgMap& prog_map,
        qprog_sequence_t& vertice_vector
        );
};

class Vertice

#include <TensorNode.h>

class Vertice
{
public:
    // construction

    Vertice();

    Vertice(
        int value,
        std::vector<qsize_t>& contect_edge
        );

    // methods

    std::vector<qsize_t>& getContectEdge();
    void addContectEdge(qsize_t);

    void setContectEdge(
        qsize_t,
        qsize_t
        );

    void setContectEdgebyID(
        qsize_t id,
        qsize_t value
        );

    void deleteContectEdge(qsize_t);
    int getValue() const;
    void setValue(int);
    void setNum(size_t num);
    size_t getNum();
};

class VerticeMatrix

#include <TensorNode.h>

class VerticeMatrix
{
public:
    // methods

    qsize_t getQubitCount() const;
    qsize_t getVerticeCount() const;
    void subVerticeCount();
    qsize_t addVertice(qsize_t);

    qsize_t addVertice(
        qsize_t,
        qsize_t
        );

    qsize_t addVertice(
        qsize_t,
        qsize_t,
        Vertice&
        );

    int getVerticeValue(
        qsize_t,
        qsize_t
        );

    qubit_vertice_t getVerticeByNum(size_t num);
    qsize_t getEmptyVertice();

    void setVerticeValue(
        qsize_t,
        qsize_t,
        int
        );

    void initVerticeMatrix(qsize_t);

    std::map<qsize_t, Vertice>::iterator deleteVertice(
        qsize_t,
        qsize_t
        );

    qsize_t getQubitVerticeLastID(qsize_t);

    std::vector<qsize_t>& getContectEdge(
        qsize_t,
        qsize_t
        );

    std::vector<qsize_t>& getContectEdgebynum(
        qsize_t,
        qsize_t
        );

    vertice_matrix_t::iterator begin();
    vertice_matrix_t::iterator end();
    vertice_matrix_t::iterator getQubitMapIter(qsize_t qubit);
    vertice_map_t::iterator getQubitMapIterBegin(qsize_t qubit);
    vertice_map_t::iterator getQubitMapIterEnd(qsize_t qubit);

    vertice_map_t::iterator getVertice(
        qsize_t,
        qsize_t
        );

    void addContectEdge(
        qsize_t,
        qsize_t,
        qsize_t
        );

    void changeContectEdge(
        qsize_t,
        qsize_t,
        qsize_t,
        qsize_t
        );

    void deleteContectEdge(
        qsize_t,
        qsize_t,
        qsize_t
        );

    void clearVertice();
    bool isEmpty();
    void clear();
};

class originirBaseVisitor

Overview

This class provides an empty implementation of originirVisitor, which can be extended to create a visitor which only needs to handle a subset of the available methods. More…

#include <originirBaseVisitor.h>

class originirBaseVisitor: public originirVisitor
{
public:
    // methods

    virtual antlrcpp::Any visitTranslationunit(originirParser::TranslationunitContext* context);
    virtual antlrcpp::Any visitDeclaration(originirParser::DeclarationContext* ctx);
    virtual antlrcpp::Any visitQinit_declaration(originirParser::Qinit_declarationContext* ctx);
    virtual antlrcpp::Any visitCinit_declaration(originirParser::Cinit_declarationContext* ctx);
    virtual antlrcpp::Any visitQuantum_gate_declaration(originirParser::Quantum_gate_declarationContext* ctx);
    virtual antlrcpp::Any visitIndex(originirParser::IndexContext* ctx);
    virtual antlrcpp::Any visitC_KEY_declaration(originirParser::C_KEY_declarationContext* ctx);
    virtual antlrcpp::Any visitQ_KEY_declaration(originirParser::Q_KEY_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_without_parameter_declaration(originirParser::Single_gate_without_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_one_parameter_declaration(originirParser::Single_gate_with_one_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_two_parameter_declaration(originirParser::Single_gate_with_two_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_three_parameter_declaration(originirParser::Single_gate_with_three_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_four_parameter_declaration(originirParser::Single_gate_with_four_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_without_parameter_declaration(originirParser::Double_gate_without_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_with_one_parameter_declaration(originirParser::Double_gate_with_one_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_with_four_parameter_declaration(originirParser::Double_gate_with_four_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitTriple_gate_without_parameter_declaration(originirParser::Triple_gate_without_parameter_declarationContext* ctx);
    virtual antlrcpp::Any visitDefine_gate_declaration(originirParser::Define_gate_declarationContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_without_parameter_type(originirParser::Single_gate_without_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_one_parameter_type(originirParser::Single_gate_with_one_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_two_parameter_type(originirParser::Single_gate_with_two_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_three_parameter_type(originirParser::Single_gate_with_three_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitSingle_gate_with_four_parameter_type(originirParser::Single_gate_with_four_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_without_parameter_type(originirParser::Double_gate_without_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_with_one_parameter_type(originirParser::Double_gate_with_one_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitDouble_gate_with_four_parameter_type(originirParser::Double_gate_with_four_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitTriple_gate_without_parameter_type(originirParser::Triple_gate_without_parameter_typeContext* ctx);
    virtual antlrcpp::Any visitPri_ckey(originirParser::Pri_ckeyContext* ctx);
    virtual antlrcpp::Any visitPri_cst(originirParser::Pri_cstContext* ctx);
    virtual antlrcpp::Any visitPri_expr(originirParser::Pri_exprContext* ctx);
    virtual antlrcpp::Any visitUnary_expression(originirParser::Unary_expressionContext* ctx);
    virtual antlrcpp::Any visitMultiplicative_expression(originirParser::Multiplicative_expressionContext* ctx);
    virtual antlrcpp::Any visitAddtive_expression(originirParser::Addtive_expressionContext* ctx);
    virtual antlrcpp::Any visitRelational_expression(originirParser::Relational_expressionContext* ctx);
    virtual antlrcpp::Any visitEquality_expression(originirParser::Equality_expressionContext* ctx);
    virtual antlrcpp::Any visitLogical_and_expression(originirParser::Logical_and_expressionContext* ctx);
    virtual antlrcpp::Any visitLogical_or_expression(originirParser::Logical_or_expressionContext* ctx);
    virtual antlrcpp::Any visitAssignment_expression(originirParser::Assignment_expressionContext* ctx);
    virtual antlrcpp::Any visitExpression(originirParser::ExpressionContext* ctx);
    virtual antlrcpp::Any visitControlbit_list(originirParser::Controlbit_listContext* ctx);
    virtual antlrcpp::Any visitStatement(originirParser::StatementContext* ctx);
    virtual antlrcpp::Any visitDagger_statement(originirParser::Dagger_statementContext* ctx);
    virtual antlrcpp::Any visitControl_statement(originirParser::Control_statementContext* ctx);
    virtual antlrcpp::Any visitQelse_statement_fragment(originirParser::Qelse_statement_fragmentContext* ctx);
    virtual antlrcpp::Any visitQif_if(originirParser::Qif_ifContext* ctx);
    virtual antlrcpp::Any visitQif_ifelse(originirParser::Qif_ifelseContext* ctx);
    virtual antlrcpp::Any visitQwhile_statement(originirParser::Qwhile_statementContext* ctx);
    virtual antlrcpp::Any visitMeasure_statement(originirParser::Measure_statementContext* ctx);
    virtual antlrcpp::Any visitReset_statement(originirParser::Reset_statementContext* ctx);
    virtual antlrcpp::Any visitBarrier_statement(originirParser::Barrier_statementContext* ctx);
    virtual antlrcpp::Any visitExpression_statement(originirParser::Expression_statementContext* ctx);
    virtual antlrcpp::Any visitDefine_gate_statement(originirParser::Define_gate_statementContext* ctx);
    virtual antlrcpp::Any visitExplist(originirParser::ExplistContext* ctx);
    virtual antlrcpp::Any visitExp(originirParser::ExpContext* ctx);
    virtual antlrcpp::Any visitGate_func_statement(originirParser::Gate_func_statementContext* ctx);
    virtual antlrcpp::Any visitId(originirParser::IdContext* ctx);
    virtual antlrcpp::Any visitId_list(originirParser::Id_listContext* ctx);
    virtual antlrcpp::Any visitGate_name(originirParser::Gate_nameContext* ctx);
    virtual antlrcpp::Any visitConstant(originirParser::ConstantContext* ctx);
};

// direct descendants

class OriginIRVisitor;

Inherited Members

public:
    // methods

    virtual antlrcpp::Any visitTranslationunit(originirParser::TranslationunitContext* context) = 0;
    virtual antlrcpp::Any visitDeclaration(originirParser::DeclarationContext* context) = 0;
    virtual antlrcpp::Any visitQinit_declaration(originirParser::Qinit_declarationContext* context) = 0;
    virtual antlrcpp::Any visitCinit_declaration(originirParser::Cinit_declarationContext* context) = 0;
    virtual antlrcpp::Any visitQuantum_gate_declaration(originirParser::Quantum_gate_declarationContext* context) = 0;
    virtual antlrcpp::Any visitIndex(originirParser::IndexContext* context) = 0;
    virtual antlrcpp::Any visitC_KEY_declaration(originirParser::C_KEY_declarationContext* context) = 0;
    virtual antlrcpp::Any visitQ_KEY_declaration(originirParser::Q_KEY_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_without_parameter_declaration(originirParser::Single_gate_without_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_one_parameter_declaration(originirParser::Single_gate_with_one_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_two_parameter_declaration(originirParser::Single_gate_with_two_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_three_parameter_declaration(originirParser::Single_gate_with_three_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_four_parameter_declaration(originirParser::Single_gate_with_four_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_without_parameter_declaration(originirParser::Double_gate_without_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_with_one_parameter_declaration(originirParser::Double_gate_with_one_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_with_four_parameter_declaration(originirParser::Double_gate_with_four_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitTriple_gate_without_parameter_declaration(originirParser::Triple_gate_without_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitDefine_gate_declaration(originirParser::Define_gate_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_without_parameter_type(originirParser::Single_gate_without_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_one_parameter_type(originirParser::Single_gate_with_one_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_two_parameter_type(originirParser::Single_gate_with_two_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_three_parameter_type(originirParser::Single_gate_with_three_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_four_parameter_type(originirParser::Single_gate_with_four_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_without_parameter_type(originirParser::Double_gate_without_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_with_one_parameter_type(originirParser::Double_gate_with_one_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_with_four_parameter_type(originirParser::Double_gate_with_four_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitTriple_gate_without_parameter_type(originirParser::Triple_gate_without_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitPri_ckey(originirParser::Pri_ckeyContext* context) = 0;
    virtual antlrcpp::Any visitPri_cst(originirParser::Pri_cstContext* context) = 0;
    virtual antlrcpp::Any visitPri_expr(originirParser::Pri_exprContext* context) = 0;
    virtual antlrcpp::Any visitUnary_expression(originirParser::Unary_expressionContext* context) = 0;
    virtual antlrcpp::Any visitMultiplicative_expression(originirParser::Multiplicative_expressionContext* context) = 0;
    virtual antlrcpp::Any visitAddtive_expression(originirParser::Addtive_expressionContext* context) = 0;
    virtual antlrcpp::Any visitRelational_expression(originirParser::Relational_expressionContext* context) = 0;
    virtual antlrcpp::Any visitEquality_expression(originirParser::Equality_expressionContext* context) = 0;
    virtual antlrcpp::Any visitLogical_and_expression(originirParser::Logical_and_expressionContext* context) = 0;
    virtual antlrcpp::Any visitLogical_or_expression(originirParser::Logical_or_expressionContext* context) = 0;
    virtual antlrcpp::Any visitAssignment_expression(originirParser::Assignment_expressionContext* context) = 0;
    virtual antlrcpp::Any visitExpression(originirParser::ExpressionContext* context) = 0;
    virtual antlrcpp::Any visitControlbit_list(originirParser::Controlbit_listContext* context) = 0;
    virtual antlrcpp::Any visitStatement(originirParser::StatementContext* context) = 0;
    virtual antlrcpp::Any visitDagger_statement(originirParser::Dagger_statementContext* context) = 0;
    virtual antlrcpp::Any visitControl_statement(originirParser::Control_statementContext* context) = 0;
    virtual antlrcpp::Any visitQelse_statement_fragment(originirParser::Qelse_statement_fragmentContext* context) = 0;
    virtual antlrcpp::Any visitQif_if(originirParser::Qif_ifContext* context) = 0;
    virtual antlrcpp::Any visitQif_ifelse(originirParser::Qif_ifelseContext* context) = 0;
    virtual antlrcpp::Any visitQwhile_statement(originirParser::Qwhile_statementContext* context) = 0;
    virtual antlrcpp::Any visitMeasure_statement(originirParser::Measure_statementContext* context) = 0;
    virtual antlrcpp::Any visitReset_statement(originirParser::Reset_statementContext* context) = 0;
    virtual antlrcpp::Any visitBarrier_statement(originirParser::Barrier_statementContext* context) = 0;
    virtual antlrcpp::Any visitExpression_statement(originirParser::Expression_statementContext* context) = 0;
    virtual antlrcpp::Any visitDefine_gate_statement(originirParser::Define_gate_statementContext* context) = 0;
    virtual antlrcpp::Any visitExplist(originirParser::ExplistContext* context) = 0;
    virtual antlrcpp::Any visitExp(originirParser::ExpContext* context) = 0;
    virtual antlrcpp::Any visitGate_func_statement(originirParser::Gate_func_statementContext* context) = 0;
    virtual antlrcpp::Any visitId(originirParser::IdContext* context) = 0;
    virtual antlrcpp::Any visitId_list(originirParser::Id_listContext* context) = 0;
    virtual antlrcpp::Any visitGate_name(originirParser::Gate_nameContext* context) = 0;
    virtual antlrcpp::Any visitConstant(originirParser::ConstantContext* context) = 0;

Detailed Documentation

This class provides an empty implementation of originirVisitor, which can be extended to create a visitor which only needs to handle a subset of the available methods.

Methods

virtual antlrcpp::Any visitTranslationunit(originirParser::TranslationunitContext* context)

Visit parse trees produced by originirParser.

class originirLexer

struct originirLexer::Initializer

#include <originirLexer.h>

class originirLexer: public Lexer
{
public:
    // enums

    enum
    {
        PI                = 1,
        QINIT_KEY         = 2,
        CREG_KEY          = 3,
        Q_KEY             = 4,
        C_KEY             = 5,
        BARRIER_KEY       = 6,
        QGATE_KEY         = 7,
        ENDQGATE_KEY      = 8,
        ECHO_GATE         = 9,
        H_GATE            = 10,
        X_GATE            = 11,
        NOT_GATE          = 12,
        T_GATE            = 13,
        S_GATE            = 14,
        Y_GATE            = 15,
        Z_GATE            = 16,
        X1_GATE           = 17,
        Y1_GATE           = 18,
        Z1_GATE           = 19,
        I_GATE            = 20,
        U2_GATE           = 21,
        RPHI_GATE         = 22,
        U3_GATE           = 23,
        U4_GATE           = 24,
        RX_GATE           = 25,
        RY_GATE           = 26,
        RZ_GATE           = 27,
        U1_GATE           = 28,
        CNOT_GATE         = 29,
        CZ_GATE           = 30,
        CU_GATE           = 31,
        ISWAP_GATE        = 32,
        SQISWAP_GATE      = 33,
        SWAPZ1_GATE       = 34,
        ISWAPTHETA_GATE   = 35,
        CR_GATE           = 36,
        TOFFOLI_GATE      = 37,
        DAGGER_KEY        = 38,
        ENDDAGGER_KEY     = 39,
        CONTROL_KEY       = 40,
        ENDCONTROL_KEY    = 41,
        QIF_KEY           = 42,
        ELSE_KEY          = 43,
        ENDIF_KEY         = 44,
        QWHILE_KEY        = 45,
        ENDQWHILE_KEY     = 46,
        MEASURE_KEY       = 47,
        RESET_KEY         = 48,
        ASSIGN            = 49,
        GT                = 50,
        LT                = 51,
        NOT               = 52,
        EQ                = 53,
        LEQ               = 54,
        GEQ               = 55,
        NE                = 56,
        AND               = 57,
        OR                = 58,
        PLUS              = 59,
        MINUS             = 60,
        MUL               = 61,
        DIV               = 62,
        COMMA             = 63,
        LPAREN            = 64,
        RPAREN            = 65,
        LBRACK            = 66,
        RBRACK            = 67,
        NEWLINE           = 68,
        Identifier        = 69,
        Integer_Literal   = 70,
        Double_Literal    = 71,
        Digit_Sequence    = 72,
        REALEXP           = 73,
        WhiteSpace        = 74,
        SingleLineComment = 75,
    };

    // structs

    struct Initializer;

    // construction

    originirLexer(antlr4::CharStream* input);

    // methods

    virtual std::string getGrammarFileName() const;
    virtual const std::vector<std::string>& getRuleNames() const;
    virtual const std::vector<std::string>& getChannelNames() const;
    virtual const std::vector<std::string>& getModeNames() const;
    virtual const std::vector<std::string>& getTokenNames() const;
    virtual antlr4::dfa::Vocabulary& getVocabulary() const;
    virtual const std::vector<uint16_t> getSerializedATN() const;
    virtual const antlr4::atn::ATN& getATN() const;
};

class originirListener

This interface defines an abstract listener for a parse tree produced by originirParser.

#include <originirListener.h>

class originirListener: public ParseTreeListener
{
public:
    // methods

    virtual void enterTranslationunit(originirParser::TranslationunitContext* ctx) = 0;
    virtual void exitTranslationunit(originirParser::TranslationunitContext* ctx) = 0;
    virtual void enterDeclaration(originirParser::DeclarationContext* ctx) = 0;
    virtual void exitDeclaration(originirParser::DeclarationContext* ctx) = 0;
    virtual void enterQinit_declaration(originirParser::Qinit_declarationContext* ctx) = 0;
    virtual void exitQinit_declaration(originirParser::Qinit_declarationContext* ctx) = 0;
    virtual void enterCinit_declaration(originirParser::Cinit_declarationContext* ctx) = 0;
    virtual void exitCinit_declaration(originirParser::Cinit_declarationContext* ctx) = 0;
    virtual void enterQuantum_gate_declaration(originirParser::Quantum_gate_declarationContext* ctx) = 0;
    virtual void exitQuantum_gate_declaration(originirParser::Quantum_gate_declarationContext* ctx) = 0;
    virtual void enterIndex(originirParser::IndexContext* ctx) = 0;
    virtual void exitIndex(originirParser::IndexContext* ctx) = 0;
    virtual void enterC_KEY_declaration(originirParser::C_KEY_declarationContext* ctx) = 0;
    virtual void exitC_KEY_declaration(originirParser::C_KEY_declarationContext* ctx) = 0;
    virtual void enterQ_KEY_declaration(originirParser::Q_KEY_declarationContext* ctx) = 0;
    virtual void exitQ_KEY_declaration(originirParser::Q_KEY_declarationContext* ctx) = 0;
    virtual void enterSingle_gate_without_parameter_declaration(originirParser::Single_gate_without_parameter_declarationContext* ctx) = 0;
    virtual void exitSingle_gate_without_parameter_declaration(originirParser::Single_gate_without_parameter_declarationContext* ctx) = 0;
    virtual void enterSingle_gate_with_one_parameter_declaration(originirParser::Single_gate_with_one_parameter_declarationContext* ctx) = 0;
    virtual void exitSingle_gate_with_one_parameter_declaration(originirParser::Single_gate_with_one_parameter_declarationContext* ctx) = 0;
    virtual void enterSingle_gate_with_two_parameter_declaration(originirParser::Single_gate_with_two_parameter_declarationContext* ctx) = 0;
    virtual void exitSingle_gate_with_two_parameter_declaration(originirParser::Single_gate_with_two_parameter_declarationContext* ctx) = 0;
    virtual void enterSingle_gate_with_three_parameter_declaration(originirParser::Single_gate_with_three_parameter_declarationContext* ctx) = 0;
    virtual void exitSingle_gate_with_three_parameter_declaration(originirParser::Single_gate_with_three_parameter_declarationContext* ctx) = 0;
    virtual void enterSingle_gate_with_four_parameter_declaration(originirParser::Single_gate_with_four_parameter_declarationContext* ctx) = 0;
    virtual void exitSingle_gate_with_four_parameter_declaration(originirParser::Single_gate_with_four_parameter_declarationContext* ctx) = 0;
    virtual void enterDouble_gate_without_parameter_declaration(originirParser::Double_gate_without_parameter_declarationContext* ctx) = 0;
    virtual void exitDouble_gate_without_parameter_declaration(originirParser::Double_gate_without_parameter_declarationContext* ctx) = 0;
    virtual void enterDouble_gate_with_one_parameter_declaration(originirParser::Double_gate_with_one_parameter_declarationContext* ctx) = 0;
    virtual void exitDouble_gate_with_one_parameter_declaration(originirParser::Double_gate_with_one_parameter_declarationContext* ctx) = 0;
    virtual void enterDouble_gate_with_four_parameter_declaration(originirParser::Double_gate_with_four_parameter_declarationContext* ctx) = 0;
    virtual void exitDouble_gate_with_four_parameter_declaration(originirParser::Double_gate_with_four_parameter_declarationContext* ctx) = 0;
    virtual void enterTriple_gate_without_parameter_declaration(originirParser::Triple_gate_without_parameter_declarationContext* ctx) = 0;
    virtual void exitTriple_gate_without_parameter_declaration(originirParser::Triple_gate_without_parameter_declarationContext* ctx) = 0;
    virtual void enterDefine_gate_declaration(originirParser::Define_gate_declarationContext* ctx) = 0;
    virtual void exitDefine_gate_declaration(originirParser::Define_gate_declarationContext* ctx) = 0;
    virtual void enterSingle_gate_without_parameter_type(originirParser::Single_gate_without_parameter_typeContext* ctx) = 0;
    virtual void exitSingle_gate_without_parameter_type(originirParser::Single_gate_without_parameter_typeContext* ctx) = 0;
    virtual void enterSingle_gate_with_one_parameter_type(originirParser::Single_gate_with_one_parameter_typeContext* ctx) = 0;
    virtual void exitSingle_gate_with_one_parameter_type(originirParser::Single_gate_with_one_parameter_typeContext* ctx) = 0;
    virtual void enterSingle_gate_with_two_parameter_type(originirParser::Single_gate_with_two_parameter_typeContext* ctx) = 0;
    virtual void exitSingle_gate_with_two_parameter_type(originirParser::Single_gate_with_two_parameter_typeContext* ctx) = 0;
    virtual void enterSingle_gate_with_three_parameter_type(originirParser::Single_gate_with_three_parameter_typeContext* ctx) = 0;
    virtual void exitSingle_gate_with_three_parameter_type(originirParser::Single_gate_with_three_parameter_typeContext* ctx) = 0;
    virtual void enterSingle_gate_with_four_parameter_type(originirParser::Single_gate_with_four_parameter_typeContext* ctx) = 0;
    virtual void exitSingle_gate_with_four_parameter_type(originirParser::Single_gate_with_four_parameter_typeContext* ctx) = 0;
    virtual void enterDouble_gate_without_parameter_type(originirParser::Double_gate_without_parameter_typeContext* ctx) = 0;
    virtual void exitDouble_gate_without_parameter_type(originirParser::Double_gate_without_parameter_typeContext* ctx) = 0;
    virtual void enterDouble_gate_with_one_parameter_type(originirParser::Double_gate_with_one_parameter_typeContext* ctx) = 0;
    virtual void exitDouble_gate_with_one_parameter_type(originirParser::Double_gate_with_one_parameter_typeContext* ctx) = 0;
    virtual void enterDouble_gate_with_four_parameter_type(originirParser::Double_gate_with_four_parameter_typeContext* ctx) = 0;
    virtual void exitDouble_gate_with_four_parameter_type(originirParser::Double_gate_with_four_parameter_typeContext* ctx) = 0;
    virtual void enterTriple_gate_without_parameter_type(originirParser::Triple_gate_without_parameter_typeContext* ctx) = 0;
    virtual void exitTriple_gate_without_parameter_type(originirParser::Triple_gate_without_parameter_typeContext* ctx) = 0;
    virtual void enterPri_ckey(originirParser::Pri_ckeyContext* ctx) = 0;
    virtual void exitPri_ckey(originirParser::Pri_ckeyContext* ctx) = 0;
    virtual void enterPri_cst(originirParser::Pri_cstContext* ctx) = 0;
    virtual void exitPri_cst(originirParser::Pri_cstContext* ctx) = 0;
    virtual void enterPri_expr(originirParser::Pri_exprContext* ctx) = 0;
    virtual void exitPri_expr(originirParser::Pri_exprContext* ctx) = 0;
    virtual void enterUnary_expression(originirParser::Unary_expressionContext* ctx) = 0;
    virtual void exitUnary_expression(originirParser::Unary_expressionContext* ctx) = 0;
    virtual void enterMultiplicative_expression(originirParser::Multiplicative_expressionContext* ctx) = 0;
    virtual void exitMultiplicative_expression(originirParser::Multiplicative_expressionContext* ctx) = 0;
    virtual void enterAddtive_expression(originirParser::Addtive_expressionContext* ctx) = 0;
    virtual void exitAddtive_expression(originirParser::Addtive_expressionContext* ctx) = 0;
    virtual void enterRelational_expression(originirParser::Relational_expressionContext* ctx) = 0;
    virtual void exitRelational_expression(originirParser::Relational_expressionContext* ctx) = 0;
    virtual void enterEquality_expression(originirParser::Equality_expressionContext* ctx) = 0;
    virtual void exitEquality_expression(originirParser::Equality_expressionContext* ctx) = 0;
    virtual void enterLogical_and_expression(originirParser::Logical_and_expressionContext* ctx) = 0;
    virtual void exitLogical_and_expression(originirParser::Logical_and_expressionContext* ctx) = 0;
    virtual void enterLogical_or_expression(originirParser::Logical_or_expressionContext* ctx) = 0;
    virtual void exitLogical_or_expression(originirParser::Logical_or_expressionContext* ctx) = 0;
    virtual void enterAssignment_expression(originirParser::Assignment_expressionContext* ctx) = 0;
    virtual void exitAssignment_expression(originirParser::Assignment_expressionContext* ctx) = 0;
    virtual void enterExpression(originirParser::ExpressionContext* ctx) = 0;
    virtual void exitExpression(originirParser::ExpressionContext* ctx) = 0;
    virtual void enterControlbit_list(originirParser::Controlbit_listContext* ctx) = 0;
    virtual void exitControlbit_list(originirParser::Controlbit_listContext* ctx) = 0;
    virtual void enterStatement(originirParser::StatementContext* ctx) = 0;
    virtual void exitStatement(originirParser::StatementContext* ctx) = 0;
    virtual void enterDagger_statement(originirParser::Dagger_statementContext* ctx) = 0;
    virtual void exitDagger_statement(originirParser::Dagger_statementContext* ctx) = 0;
    virtual void enterControl_statement(originirParser::Control_statementContext* ctx) = 0;
    virtual void exitControl_statement(originirParser::Control_statementContext* ctx) = 0;
    virtual void enterQelse_statement_fragment(originirParser::Qelse_statement_fragmentContext* ctx) = 0;
    virtual void exitQelse_statement_fragment(originirParser::Qelse_statement_fragmentContext* ctx) = 0;
    virtual void enterQif_if(originirParser::Qif_ifContext* ctx) = 0;
    virtual void exitQif_if(originirParser::Qif_ifContext* ctx) = 0;
    virtual void enterQif_ifelse(originirParser::Qif_ifelseContext* ctx) = 0;
    virtual void exitQif_ifelse(originirParser::Qif_ifelseContext* ctx) = 0;
    virtual void enterQwhile_statement(originirParser::Qwhile_statementContext* ctx) = 0;
    virtual void exitQwhile_statement(originirParser::Qwhile_statementContext* ctx) = 0;
    virtual void enterMeasure_statement(originirParser::Measure_statementContext* ctx) = 0;
    virtual void exitMeasure_statement(originirParser::Measure_statementContext* ctx) = 0;
    virtual void enterReset_statement(originirParser::Reset_statementContext* ctx) = 0;
    virtual void exitReset_statement(originirParser::Reset_statementContext* ctx) = 0;
    virtual void enterBarrier_statement(originirParser::Barrier_statementContext* ctx) = 0;
    virtual void exitBarrier_statement(originirParser::Barrier_statementContext* ctx) = 0;
    virtual void enterExpression_statement(originirParser::Expression_statementContext* ctx) = 0;
    virtual void exitExpression_statement(originirParser::Expression_statementContext* ctx) = 0;
    virtual void enterDefine_gate_statement(originirParser::Define_gate_statementContext* ctx) = 0;
    virtual void exitDefine_gate_statement(originirParser::Define_gate_statementContext* ctx) = 0;
    virtual void enterExplist(originirParser::ExplistContext* ctx) = 0;
    virtual void exitExplist(originirParser::ExplistContext* ctx) = 0;
    virtual void enterExp(originirParser::ExpContext* ctx) = 0;
    virtual void exitExp(originirParser::ExpContext* ctx) = 0;
    virtual void enterGate_func_statement(originirParser::Gate_func_statementContext* ctx) = 0;
    virtual void exitGate_func_statement(originirParser::Gate_func_statementContext* ctx) = 0;
    virtual void enterId(originirParser::IdContext* ctx) = 0;
    virtual void exitId(originirParser::IdContext* ctx) = 0;
    virtual void enterId_list(originirParser::Id_listContext* ctx) = 0;
    virtual void exitId_list(originirParser::Id_listContext* ctx) = 0;
    virtual void enterGate_name(originirParser::Gate_nameContext* ctx) = 0;
    virtual void exitGate_name(originirParser::Gate_nameContext* ctx) = 0;
    virtual void enterConstant(originirParser::ConstantContext* ctx) = 0;
    virtual void exitConstant(originirParser::ConstantContext* ctx) = 0;
};

class originirParser

struct originirParser::Initializer

class originirParser::Addtive_expressionContext

#include <originirParser.h>

class Addtive_expressionContext: public ParserRuleContext
{
public:
    // construction

    Addtive_expressionContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Multiplicative_expressionContext* multiplicative_expression();
    Addtive_expressionContext* addtive_expression();
    antlr4::tree::TerminalNode* PLUS();
    antlr4::tree::TerminalNode* MINUS();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Assignment_expressionContext

#include <originirParser.h>

class Assignment_expressionContext: public ParserRuleContext
{
public:
    // construction

    Assignment_expressionContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Logical_or_expressionContext* logical_or_expression();
    C_KEY_declarationContext* c_KEY_declaration();
    antlr4::tree::TerminalNode* ASSIGN();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Barrier_statementContext

#include <originirParser.h>

class Barrier_statementContext: public ParserRuleContext
{
public:
    // construction

    Barrier_statementContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* BARRIER_KEY();
    Controlbit_listContext* controlbit_list();
    antlr4::tree::TerminalNode* NEWLINE();
    antlr4::tree::TerminalNode* Q_KEY();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::C_KEY_declarationContext

#include <originirParser.h>

class C_KEY_declarationContext: public ParserRuleContext
{
public:
    // construction

    C_KEY_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* C_KEY();
    IndexContext* index();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Cinit_declarationContext

#include <originirParser.h>

class Cinit_declarationContext: public ParserRuleContext
{
public:
    // construction

    Cinit_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* CREG_KEY();
    antlr4::tree::TerminalNode* Integer_Literal();
    antlr4::tree::TerminalNode* NEWLINE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::ConstantContext

#include <originirParser.h>

class ConstantContext: public ParserRuleContext
{
public:
    // construction

    ConstantContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* Integer_Literal();
    antlr4::tree::TerminalNode* Double_Literal();
    antlr4::tree::TerminalNode* PI();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Control_statementContext

#include <originirParser.h>

class Control_statementContext: public ParserRuleContext
{
public:
    // construction

    Control_statementContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* CONTROL_KEY();
    Controlbit_listContext* controlbit_list();
    std::vector<antlr4::tree::TerminalNode*> NEWLINE();
    antlr4::tree::TerminalNode* NEWLINE(size_t i);
    antlr4::tree::TerminalNode* ENDCONTROL_KEY();
    std::vector<StatementContext*> statement();
    StatementContext* statement(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Controlbit_listContext

#include <originirParser.h>

class Controlbit_listContext: public ParserRuleContext
{
public:
    // construction

    Controlbit_listContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    std::vector<Q_KEY_declarationContext*> q_KEY_declaration();
    Q_KEY_declarationContext* q_KEY_declaration(size_t i);
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Dagger_statementContext

#include <originirParser.h>

class Dagger_statementContext: public ParserRuleContext
{
public:
    // construction

    Dagger_statementContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* DAGGER_KEY();
    std::vector<antlr4::tree::TerminalNode*> NEWLINE();
    antlr4::tree::TerminalNode* NEWLINE(size_t i);
    antlr4::tree::TerminalNode* ENDDAGGER_KEY();
    std::vector<StatementContext*> statement();
    StatementContext* statement(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::DeclarationContext

#include <originirParser.h>

class DeclarationContext: public ParserRuleContext
{
public:
    // construction

    DeclarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Qinit_declarationContext* qinit_declaration();
    Cinit_declarationContext* cinit_declaration();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Define_gate_declarationContext

#include <originirParser.h>

class Define_gate_declarationContext: public ParserRuleContext
{
public:
    // construction

    Define_gate_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    IdContext* id();
    std::vector<Q_KEY_declarationContext*> q_KEY_declaration();
    Q_KEY_declarationContext* q_KEY_declaration(size_t i);
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    antlr4::tree::TerminalNode* LPAREN();
    std::vector<ExpressionContext*> expression();
    ExpressionContext* expression(size_t i);
    antlr4::tree::TerminalNode* RPAREN();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Define_gate_statementContext

#include <originirParser.h>

class Define_gate_statementContext: public ParserRuleContext
{
public:
    // construction

    Define_gate_statementContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Gate_nameContext* gate_name();
    Id_listContext* id_list();
    antlr4::tree::TerminalNode* NEWLINE();
    antlr4::tree::TerminalNode* COMMA();
    antlr4::tree::TerminalNode* LPAREN();
    ExplistContext* explist();
    antlr4::tree::TerminalNode* RPAREN();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Double_gate_with_four_parameter_declarationContext

#include <originirParser.h>

class Double_gate_with_four_parameter_declarationContext: public ParserRuleContext
{
public:
    // construction

    Double_gate_with_four_parameter_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Double_gate_with_four_parameter_typeContext* double_gate_with_four_parameter_type();
    std::vector<Q_KEY_declarationContext*> q_KEY_declaration();
    Q_KEY_declarationContext* q_KEY_declaration(size_t i);
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    antlr4::tree::TerminalNode* LPAREN();
    std::vector<ExpressionContext*> expression();
    ExpressionContext* expression(size_t i);
    antlr4::tree::TerminalNode* RPAREN();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Double_gate_with_four_parameter_typeContext

#include <originirParser.h>

class Double_gate_with_four_parameter_typeContext: public ParserRuleContext
{
public:
    // construction

    Double_gate_with_four_parameter_typeContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* CU_GATE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Double_gate_with_one_parameter_declarationContext

#include <originirParser.h>

class Double_gate_with_one_parameter_declarationContext: public ParserRuleContext
{
public:
    // construction

    Double_gate_with_one_parameter_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Double_gate_with_one_parameter_typeContext* double_gate_with_one_parameter_type();
    std::vector<Q_KEY_declarationContext*> q_KEY_declaration();
    Q_KEY_declarationContext* q_KEY_declaration(size_t i);
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    antlr4::tree::TerminalNode* LPAREN();
    ExpressionContext* expression();
    antlr4::tree::TerminalNode* RPAREN();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Double_gate_with_one_parameter_typeContext

#include <originirParser.h>

class Double_gate_with_one_parameter_typeContext: public ParserRuleContext
{
public:
    // construction

    Double_gate_with_one_parameter_typeContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* ISWAPTHETA_GATE();
    antlr4::tree::TerminalNode* CR_GATE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Double_gate_without_parameter_declarationContext

#include <originirParser.h>

class Double_gate_without_parameter_declarationContext: public ParserRuleContext
{
public:
    // construction

    Double_gate_without_parameter_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Double_gate_without_parameter_typeContext* double_gate_without_parameter_type();
    std::vector<Q_KEY_declarationContext*> q_KEY_declaration();
    Q_KEY_declarationContext* q_KEY_declaration(size_t i);
    antlr4::tree::TerminalNode* COMMA();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Double_gate_without_parameter_typeContext

#include <originirParser.h>

class Double_gate_without_parameter_typeContext: public ParserRuleContext
{
public:
    // construction

    Double_gate_without_parameter_typeContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* CNOT_GATE();
    antlr4::tree::TerminalNode* CZ_GATE();
    antlr4::tree::TerminalNode* ISWAP_GATE();
    antlr4::tree::TerminalNode* SQISWAP_GATE();
    antlr4::tree::TerminalNode* SWAPZ1_GATE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Equality_expressionContext

#include <originirParser.h>

class Equality_expressionContext: public ParserRuleContext
{
public:
    // construction

    Equality_expressionContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Relational_expressionContext* relational_expression();
    Equality_expressionContext* equality_expression();
    antlr4::tree::TerminalNode* EQ();
    antlr4::tree::TerminalNode* NE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::ExpContext

#include <originirParser.h>

class ExpContext: public ParserRuleContext
{
public:
    // construction

    ExpContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    IdContext* id();
    antlr4::tree::TerminalNode* Integer_Literal();
    antlr4::tree::TerminalNode* Double_Literal();
    antlr4::tree::TerminalNode* PI();
    antlr4::tree::TerminalNode* LPAREN();
    std::vector<ExpContext*> exp();
    ExpContext* exp(size_t i);
    antlr4::tree::TerminalNode* RPAREN();
    antlr4::tree::TerminalNode* MINUS();
    antlr4::tree::TerminalNode* MUL();
    antlr4::tree::TerminalNode* DIV();
    antlr4::tree::TerminalNode* PLUS();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::ExplistContext

#include <originirParser.h>

class ExplistContext: public ParserRuleContext
{
public:
    // construction

    ExplistContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    std::vector<ExpContext*> exp();
    ExpContext* exp(size_t i);
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::ExpressionContext

#include <originirParser.h>

class ExpressionContext: public ParserRuleContext
{
public:
    // construction

    ExpressionContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Assignment_expressionContext* assignment_expression();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Expression_statementContext

#include <originirParser.h>

class Expression_statementContext: public ParserRuleContext
{
public:
    // construction

    Expression_statementContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    ExpressionContext* expression();
    antlr4::tree::TerminalNode* NEWLINE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Gate_func_statementContext

#include <originirParser.h>

class Gate_func_statementContext: public ParserRuleContext
{
public:
    // construction

    Gate_func_statementContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* QGATE_KEY();
    IdContext* id();
    std::vector<Id_listContext*> id_list();
    Id_listContext* id_list(size_t i);
    std::vector<antlr4::tree::TerminalNode*> NEWLINE();
    antlr4::tree::TerminalNode* NEWLINE(size_t i);
    antlr4::tree::TerminalNode* ENDQGATE_KEY();
    std::vector<Define_gate_statementContext*> define_gate_statement();
    Define_gate_statementContext* define_gate_statement(size_t i);
    antlr4::tree::TerminalNode* COMMA();
    antlr4::tree::TerminalNode* LPAREN();
    antlr4::tree::TerminalNode* RPAREN();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Gate_nameContext

#include <originirParser.h>

class Gate_nameContext: public ParserRuleContext
{
public:
    // construction

    Gate_nameContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Single_gate_without_parameter_typeContext* single_gate_without_parameter_type();
    Single_gate_with_one_parameter_typeContext* single_gate_with_one_parameter_type();
    Single_gate_with_two_parameter_typeContext* single_gate_with_two_parameter_type();
    Single_gate_with_three_parameter_typeContext* single_gate_with_three_parameter_type();
    Single_gate_with_four_parameter_typeContext* single_gate_with_four_parameter_type();
    Double_gate_without_parameter_typeContext* double_gate_without_parameter_type();
    Double_gate_with_one_parameter_typeContext* double_gate_with_one_parameter_type();
    Double_gate_with_four_parameter_typeContext* double_gate_with_four_parameter_type();
    Triple_gate_without_parameter_typeContext* triple_gate_without_parameter_type();
    IdContext* id();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::IdContext

#include <originirParser.h>

class IdContext: public ParserRuleContext
{
public:
    // construction

    IdContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* Identifier();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Id_listContext

#include <originirParser.h>

class Id_listContext: public ParserRuleContext
{
public:
    // construction

    Id_listContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    std::vector<IdContext*> id();
    IdContext* id(size_t i);
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::IndexContext

#include <originirParser.h>

class IndexContext: public ParserRuleContext
{
public:
    // construction

    IndexContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* LBRACK();
    ExpressionContext* expression();
    antlr4::tree::TerminalNode* RBRACK();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Logical_and_expressionContext

#include <originirParser.h>

class Logical_and_expressionContext: public ParserRuleContext
{
public:
    // construction

    Logical_and_expressionContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Equality_expressionContext* equality_expression();
    Logical_and_expressionContext* logical_and_expression();
    antlr4::tree::TerminalNode* AND();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Logical_or_expressionContext

#include <originirParser.h>

class Logical_or_expressionContext: public ParserRuleContext
{
public:
    // construction

    Logical_or_expressionContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Logical_and_expressionContext* logical_and_expression();
    Logical_or_expressionContext* logical_or_expression();
    antlr4::tree::TerminalNode* OR();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Measure_statementContext

#include <originirParser.h>

class Measure_statementContext: public ParserRuleContext
{
public:
    // construction

    Measure_statementContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* MEASURE_KEY();
    Q_KEY_declarationContext* q_KEY_declaration();
    antlr4::tree::TerminalNode* COMMA();
    C_KEY_declarationContext* c_KEY_declaration();
    antlr4::tree::TerminalNode* NEWLINE();
    antlr4::tree::TerminalNode* Q_KEY();
    antlr4::tree::TerminalNode* C_KEY();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Multiplicative_expressionContext

#include <originirParser.h>

class Multiplicative_expressionContext: public ParserRuleContext
{
public:
    // construction

    Multiplicative_expressionContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Unary_expressionContext* unary_expression();
    Multiplicative_expressionContext* multiplicative_expression();
    antlr4::tree::TerminalNode* MUL();
    antlr4::tree::TerminalNode* DIV();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Pri_ckeyContext

#include <originirParser.h>

class Pri_ckeyContext: public originirParser::Primary_expressionContext
{
public:
    // construction

    Pri_ckeyContext(Primary_expressionContext* ctx);

    // methods

    C_KEY_declarationContext* c_KEY_declaration();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

Inherited Members

public:
    // methods

    void copyFrom(Primary_expressionContext* context);
    virtual size_t getRuleIndex() const;

class originirParser::Pri_cstContext

#include <originirParser.h>

class Pri_cstContext: public originirParser::Primary_expressionContext
{
public:
    // construction

    Pri_cstContext(Primary_expressionContext* ctx);

    // methods

    ConstantContext* constant();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

Inherited Members

public:
    // methods

    void copyFrom(Primary_expressionContext* context);
    virtual size_t getRuleIndex() const;

class originirParser::Pri_exprContext

#include <originirParser.h>

class Pri_exprContext: public originirParser::Primary_expressionContext
{
public:
    // construction

    Pri_exprContext(Primary_expressionContext* ctx);

    // methods

    std::vector<antlr4::tree::TerminalNode*> LPAREN();
    antlr4::tree::TerminalNode* LPAREN(size_t i);
    ExpressionContext* expression();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

Inherited Members

public:
    // methods

    void copyFrom(Primary_expressionContext* context);
    virtual size_t getRuleIndex() const;

class originirParser::Primary_expressionContext

#include <originirParser.h>

class Primary_expressionContext: public ParserRuleContext
{
public:
    // construction

    Primary_expressionContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    Primary_expressionContext();

    // methods

    void copyFrom(Primary_expressionContext* context);
    virtual size_t getRuleIndex() const;
};

// direct descendants

class Pri_ckeyContext;
class Pri_cstContext;
class Pri_exprContext;

class originirParser::Q_KEY_declarationContext

#include <originirParser.h>

class Q_KEY_declarationContext: public ParserRuleContext
{
public:
    // construction

    Q_KEY_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* Q_KEY();
    IndexContext* index();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Qelse_statement_fragmentContext

#include <originirParser.h>

class Qelse_statement_fragmentContext: public ParserRuleContext
{
public:
    // construction

    Qelse_statement_fragmentContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* ELSE_KEY();
    antlr4::tree::TerminalNode* NEWLINE();
    std::vector<StatementContext*> statement();
    StatementContext* statement(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Qif_ifContext

#include <originirParser.h>

class Qif_ifContext: public originirParser::Qif_statementContext
{
public:
    // construction

    Qif_ifContext(Qif_statementContext* ctx);

    // methods

    antlr4::tree::TerminalNode* QIF_KEY();
    ExpressionContext* expression();
    std::vector<antlr4::tree::TerminalNode*> NEWLINE();
    antlr4::tree::TerminalNode* NEWLINE(size_t i);
    Qelse_statement_fragmentContext* qelse_statement_fragment();
    antlr4::tree::TerminalNode* ENDIF_KEY();
    std::vector<StatementContext*> statement();
    StatementContext* statement(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

Inherited Members

public:
    // methods

    void copyFrom(Qif_statementContext* context);
    virtual size_t getRuleIndex() const;

class originirParser::Qif_ifelseContext

#include <originirParser.h>

class Qif_ifelseContext: public originirParser::Qif_statementContext
{
public:
    // construction

    Qif_ifelseContext(Qif_statementContext* ctx);

    // methods

    antlr4::tree::TerminalNode* QIF_KEY();
    ExpressionContext* expression();
    std::vector<antlr4::tree::TerminalNode*> NEWLINE();
    antlr4::tree::TerminalNode* NEWLINE(size_t i);
    antlr4::tree::TerminalNode* ENDIF_KEY();
    std::vector<StatementContext*> statement();
    StatementContext* statement(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

Inherited Members

public:
    // methods

    void copyFrom(Qif_statementContext* context);
    virtual size_t getRuleIndex() const;

class originirParser::Qif_statementContext

#include <originirParser.h>

class Qif_statementContext: public ParserRuleContext
{
public:
    // construction

    Qif_statementContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    Qif_statementContext();

    // methods

    void copyFrom(Qif_statementContext* context);
    virtual size_t getRuleIndex() const;
};

// direct descendants

class Qif_ifContext;
class Qif_ifelseContext;

class originirParser::Qinit_declarationContext

#include <originirParser.h>

class Qinit_declarationContext: public ParserRuleContext
{
public:
    // construction

    Qinit_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* QINIT_KEY();
    antlr4::tree::TerminalNode* Integer_Literal();
    antlr4::tree::TerminalNode* NEWLINE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Quantum_gate_declarationContext

#include <originirParser.h>

class Quantum_gate_declarationContext: public ParserRuleContext
{
public:
    // construction

    Quantum_gate_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Single_gate_without_parameter_declarationContext* single_gate_without_parameter_declaration();
    Single_gate_with_one_parameter_declarationContext* single_gate_with_one_parameter_declaration();
    Single_gate_with_two_parameter_declarationContext* single_gate_with_two_parameter_declaration();
    Single_gate_with_three_parameter_declarationContext* single_gate_with_three_parameter_declaration();
    Single_gate_with_four_parameter_declarationContext* single_gate_with_four_parameter_declaration();
    Double_gate_without_parameter_declarationContext* double_gate_without_parameter_declaration();
    Double_gate_with_one_parameter_declarationContext* double_gate_with_one_parameter_declaration();
    Double_gate_with_four_parameter_declarationContext* double_gate_with_four_parameter_declaration();
    Triple_gate_without_parameter_declarationContext* triple_gate_without_parameter_declaration();
    Define_gate_declarationContext* define_gate_declaration();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Qwhile_statementContext

#include <originirParser.h>

class Qwhile_statementContext: public ParserRuleContext
{
public:
    // construction

    Qwhile_statementContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* QWHILE_KEY();
    ExpressionContext* expression();
    std::vector<antlr4::tree::TerminalNode*> NEWLINE();
    antlr4::tree::TerminalNode* NEWLINE(size_t i);
    antlr4::tree::TerminalNode* ENDQWHILE_KEY();
    std::vector<StatementContext*> statement();
    StatementContext* statement(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Relational_expressionContext

#include <originirParser.h>

class Relational_expressionContext: public ParserRuleContext
{
public:
    // construction

    Relational_expressionContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Addtive_expressionContext* addtive_expression();
    Relational_expressionContext* relational_expression();
    antlr4::tree::TerminalNode* LT();
    antlr4::tree::TerminalNode* GT();
    antlr4::tree::TerminalNode* LEQ();
    antlr4::tree::TerminalNode* GEQ();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Reset_statementContext

#include <originirParser.h>

class Reset_statementContext: public ParserRuleContext
{
public:
    // construction

    Reset_statementContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* RESET_KEY();
    Q_KEY_declarationContext* q_KEY_declaration();
    antlr4::tree::TerminalNode* NEWLINE();
    antlr4::tree::TerminalNode* Q_KEY();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Single_gate_with_four_parameter_declarationContext

#include <originirParser.h>

class Single_gate_with_four_parameter_declarationContext: public ParserRuleContext
{
public:
    // construction

    Single_gate_with_four_parameter_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Single_gate_with_four_parameter_typeContext* single_gate_with_four_parameter_type();
    Q_KEY_declarationContext* q_KEY_declaration();
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    antlr4::tree::TerminalNode* LPAREN();
    std::vector<ExpressionContext*> expression();
    ExpressionContext* expression(size_t i);
    antlr4::tree::TerminalNode* RPAREN();
    antlr4::tree::TerminalNode* Q_KEY();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Single_gate_with_four_parameter_typeContext

#include <originirParser.h>

class Single_gate_with_four_parameter_typeContext: public ParserRuleContext
{
public:
    // construction

    Single_gate_with_four_parameter_typeContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* U4_GATE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Single_gate_with_one_parameter_declarationContext

#include <originirParser.h>

class Single_gate_with_one_parameter_declarationContext: public ParserRuleContext
{
public:
    // construction

    Single_gate_with_one_parameter_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Single_gate_with_one_parameter_typeContext* single_gate_with_one_parameter_type();
    Q_KEY_declarationContext* q_KEY_declaration();
    antlr4::tree::TerminalNode* COMMA();
    antlr4::tree::TerminalNode* LPAREN();
    ExpressionContext* expression();
    antlr4::tree::TerminalNode* RPAREN();
    antlr4::tree::TerminalNode* Q_KEY();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Single_gate_with_one_parameter_typeContext

#include <originirParser.h>

class Single_gate_with_one_parameter_typeContext: public ParserRuleContext
{
public:
    // construction

    Single_gate_with_one_parameter_typeContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* RX_GATE();
    antlr4::tree::TerminalNode* RY_GATE();
    antlr4::tree::TerminalNode* RZ_GATE();
    antlr4::tree::TerminalNode* U1_GATE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Single_gate_with_three_parameter_declarationContext

#include <originirParser.h>

class Single_gate_with_three_parameter_declarationContext: public ParserRuleContext
{
public:
    // construction

    Single_gate_with_three_parameter_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Single_gate_with_three_parameter_typeContext* single_gate_with_three_parameter_type();
    Q_KEY_declarationContext* q_KEY_declaration();
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    antlr4::tree::TerminalNode* LPAREN();
    std::vector<ExpressionContext*> expression();
    ExpressionContext* expression(size_t i);
    antlr4::tree::TerminalNode* RPAREN();
    antlr4::tree::TerminalNode* Q_KEY();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Single_gate_with_three_parameter_typeContext

#include <originirParser.h>

class Single_gate_with_three_parameter_typeContext: public ParserRuleContext
{
public:
    // construction

    Single_gate_with_three_parameter_typeContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* U3_GATE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Single_gate_with_two_parameter_declarationContext

#include <originirParser.h>

class Single_gate_with_two_parameter_declarationContext: public ParserRuleContext
{
public:
    // construction

    Single_gate_with_two_parameter_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Single_gate_with_two_parameter_typeContext* single_gate_with_two_parameter_type();
    Q_KEY_declarationContext* q_KEY_declaration();
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    antlr4::tree::TerminalNode* LPAREN();
    std::vector<ExpressionContext*> expression();
    ExpressionContext* expression(size_t i);
    antlr4::tree::TerminalNode* RPAREN();
    antlr4::tree::TerminalNode* Q_KEY();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Single_gate_with_two_parameter_typeContext

#include <originirParser.h>

class Single_gate_with_two_parameter_typeContext: public ParserRuleContext
{
public:
    // construction

    Single_gate_with_two_parameter_typeContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* U2_GATE();
    antlr4::tree::TerminalNode* RPHI_GATE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Single_gate_without_parameter_declarationContext

#include <originirParser.h>

class Single_gate_without_parameter_declarationContext: public ParserRuleContext
{
public:
    // construction

    Single_gate_without_parameter_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Single_gate_without_parameter_typeContext* single_gate_without_parameter_type();
    Q_KEY_declarationContext* q_KEY_declaration();
    antlr4::tree::TerminalNode* Q_KEY();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Single_gate_without_parameter_typeContext

#include <originirParser.h>

class Single_gate_without_parameter_typeContext: public ParserRuleContext
{
public:
    // construction

    Single_gate_without_parameter_typeContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* H_GATE();
    antlr4::tree::TerminalNode* T_GATE();
    antlr4::tree::TerminalNode* S_GATE();
    antlr4::tree::TerminalNode* X_GATE();
    antlr4::tree::TerminalNode* Y_GATE();
    antlr4::tree::TerminalNode* Z_GATE();
    antlr4::tree::TerminalNode* X1_GATE();
    antlr4::tree::TerminalNode* Y1_GATE();
    antlr4::tree::TerminalNode* Z1_GATE();
    antlr4::tree::TerminalNode* I_GATE();
    antlr4::tree::TerminalNode* ECHO_GATE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::StatementContext

#include <originirParser.h>

class StatementContext: public ParserRuleContext
{
public:
    // construction

    StatementContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Quantum_gate_declarationContext* quantum_gate_declaration();
    antlr4::tree::TerminalNode* NEWLINE();
    Control_statementContext* control_statement();
    Qif_statementContext* qif_statement();
    Qwhile_statementContext* qwhile_statement();
    Dagger_statementContext* dagger_statement();
    Measure_statementContext* measure_statement();
    Reset_statementContext* reset_statement();
    Expression_statementContext* expression_statement();
    Barrier_statementContext* barrier_statement();
    Gate_func_statementContext* gate_func_statement();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::TranslationunitContext

#include <originirParser.h>

class TranslationunitContext: public ParserRuleContext
{
public:
    // construction

    TranslationunitContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    DeclarationContext* declaration();
    std::vector<StatementContext*> statement();
    StatementContext* statement(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Triple_gate_without_parameter_declarationContext

#include <originirParser.h>

class Triple_gate_without_parameter_declarationContext: public ParserRuleContext
{
public:
    // construction

    Triple_gate_without_parameter_declarationContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Triple_gate_without_parameter_typeContext* triple_gate_without_parameter_type();
    std::vector<Q_KEY_declarationContext*> q_KEY_declaration();
    Q_KEY_declarationContext* q_KEY_declaration(size_t i);
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Triple_gate_without_parameter_typeContext

#include <originirParser.h>

class Triple_gate_without_parameter_typeContext: public ParserRuleContext
{
public:
    // construction

    Triple_gate_without_parameter_typeContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* TOFFOLI_GATE();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class originirParser::Unary_expressionContext

#include <originirParser.h>

class Unary_expressionContext: public ParserRuleContext
{
public:
    // construction

    Unary_expressionContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Primary_expressionContext* primary_expression();
    antlr4::tree::TerminalNode* PLUS();
    antlr4::tree::TerminalNode* MINUS();
    antlr4::tree::TerminalNode* NOT();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

#include <originirParser.h>

class originirParser: public Parser
{
public:
    // enums

    enum
    {
        PI                = 1,
        QINIT_KEY         = 2,
        CREG_KEY          = 3,
        Q_KEY             = 4,
        C_KEY             = 5,
        BARRIER_KEY       = 6,
        QGATE_KEY         = 7,
        ENDQGATE_KEY      = 8,
        ECHO_GATE         = 9,
        H_GATE            = 10,
        X_GATE            = 11,
        NOT_GATE          = 12,
        T_GATE            = 13,
        S_GATE            = 14,
        Y_GATE            = 15,
        Z_GATE            = 16,
        X1_GATE           = 17,
        Y1_GATE           = 18,
        Z1_GATE           = 19,
        I_GATE            = 20,
        U2_GATE           = 21,
        RPHI_GATE         = 22,
        U3_GATE           = 23,
        U4_GATE           = 24,
        RX_GATE           = 25,
        RY_GATE           = 26,
        RZ_GATE           = 27,
        U1_GATE           = 28,
        CNOT_GATE         = 29,
        CZ_GATE           = 30,
        CU_GATE           = 31,
        ISWAP_GATE        = 32,
        SQISWAP_GATE      = 33,
        SWAPZ1_GATE       = 34,
        ISWAPTHETA_GATE   = 35,
        CR_GATE           = 36,
        TOFFOLI_GATE      = 37,
        DAGGER_KEY        = 38,
        ENDDAGGER_KEY     = 39,
        CONTROL_KEY       = 40,
        ENDCONTROL_KEY    = 41,
        QIF_KEY           = 42,
        ELSE_KEY          = 43,
        ENDIF_KEY         = 44,
        QWHILE_KEY        = 45,
        ENDQWHILE_KEY     = 46,
        MEASURE_KEY       = 47,
        RESET_KEY         = 48,
        ASSIGN            = 49,
        GT                = 50,
        LT                = 51,
        NOT               = 52,
        EQ                = 53,
        LEQ               = 54,
        GEQ               = 55,
        NE                = 56,
        AND               = 57,
        OR                = 58,
        PLUS              = 59,
        MINUS             = 60,
        MUL               = 61,
        DIV               = 62,
        COMMA             = 63,
        LPAREN            = 64,
        RPAREN            = 65,
        LBRACK            = 66,
        RBRACK            = 67,
        NEWLINE           = 68,
        Identifier        = 69,
        Integer_Literal   = 70,
        Double_Literal    = 71,
        Digit_Sequence    = 72,
        REALEXP           = 73,
        WhiteSpace        = 74,
        SingleLineComment = 75,
    };

    enum
    {
        RuleTranslationunit                              = 0,
        RuleDeclaration                                  = 1,
        RuleQinit_declaration                            = 2,
        RuleCinit_declaration                            = 3,
        RuleQuantum_gate_declaration                     = 4,
        RuleIndex                                        = 5,
        RuleC_KEY_declaration                            = 6,
        RuleQ_KEY_declaration                            = 7,
        RuleSingle_gate_without_parameter_declaration    = 8,
        RuleSingle_gate_with_one_parameter_declaration   = 9,
        RuleSingle_gate_with_two_parameter_declaration   = 10,
        RuleSingle_gate_with_three_parameter_declaration = 11,
        RuleSingle_gate_with_four_parameter_declaration  = 12,
        RuleDouble_gate_without_parameter_declaration    = 13,
        RuleDouble_gate_with_one_parameter_declaration   = 14,
        RuleDouble_gate_with_four_parameter_declaration  = 15,
        RuleTriple_gate_without_parameter_declaration    = 16,
        RuleDefine_gate_declaration                      = 17,
        RuleSingle_gate_without_parameter_type           = 18,
        RuleSingle_gate_with_one_parameter_type          = 19,
        RuleSingle_gate_with_two_parameter_type          = 20,
        RuleSingle_gate_with_three_parameter_type        = 21,
        RuleSingle_gate_with_four_parameter_type         = 22,
        RuleDouble_gate_without_parameter_type           = 23,
        RuleDouble_gate_with_one_parameter_type          = 24,
        RuleDouble_gate_with_four_parameter_type         = 25,
        RuleTriple_gate_without_parameter_type           = 26,
        RulePrimary_expression                           = 27,
        RuleUnary_expression                             = 28,
        RuleMultiplicative_expression                    = 29,
        RuleAddtive_expression                           = 30,
        RuleRelational_expression                        = 31,
        RuleEquality_expression                          = 32,
        RuleLogical_and_expression                       = 33,
        RuleLogical_or_expression                        = 34,
        RuleAssignment_expression                        = 35,
        RuleExpression                                   = 36,
        RuleControlbit_list                              = 37,
        RuleStatement                                    = 38,
        RuleDagger_statement                             = 39,
        RuleControl_statement                            = 40,
        RuleQelse_statement_fragment                     = 41,
        RuleQif_statement                                = 42,
        RuleQwhile_statement                             = 43,
        RuleMeasure_statement                            = 44,
        RuleReset_statement                              = 45,
        RuleBarrier_statement                            = 46,
        RuleExpression_statement                         = 47,
        RuleDefine_gate_statement                        = 48,
        RuleExplist                                      = 49,
        RuleExp                                          = 50,
        RuleGate_func_statement                          = 51,
        RuleId                                           = 52,
        RuleId_list                                      = 53,
        RuleGate_name                                    = 54,
        RuleConstant                                     = 55,
    };

    // structs

    struct Initializer;

    // classes

    class Addtive_expressionContext;
    class Assignment_expressionContext;
    class Barrier_statementContext;
    class C_KEY_declarationContext;
    class Cinit_declarationContext;
    class ConstantContext;
    class Control_statementContext;
    class Controlbit_listContext;
    class Dagger_statementContext;
    class DeclarationContext;
    class Define_gate_declarationContext;
    class Define_gate_statementContext;
    class Double_gate_with_four_parameter_declarationContext;
    class Double_gate_with_four_parameter_typeContext;
    class Double_gate_with_one_parameter_declarationContext;
    class Double_gate_with_one_parameter_typeContext;
    class Double_gate_without_parameter_declarationContext;
    class Double_gate_without_parameter_typeContext;
    class Equality_expressionContext;
    class ExpContext;
    class ExplistContext;
    class ExpressionContext;
    class Expression_statementContext;
    class Gate_func_statementContext;
    class Gate_nameContext;
    class IdContext;
    class Id_listContext;
    class IndexContext;
    class Logical_and_expressionContext;
    class Logical_or_expressionContext;
    class Measure_statementContext;
    class Multiplicative_expressionContext;
    class Pri_ckeyContext;
    class Pri_cstContext;
    class Pri_exprContext;
    class Primary_expressionContext;
    class Q_KEY_declarationContext;
    class Qelse_statement_fragmentContext;
    class Qif_ifContext;
    class Qif_ifelseContext;
    class Qif_statementContext;
    class Qinit_declarationContext;
    class Quantum_gate_declarationContext;
    class Qwhile_statementContext;
    class Relational_expressionContext;
    class Reset_statementContext;
    class Single_gate_with_four_parameter_declarationContext;
    class Single_gate_with_four_parameter_typeContext;
    class Single_gate_with_one_parameter_declarationContext;
    class Single_gate_with_one_parameter_typeContext;
    class Single_gate_with_three_parameter_declarationContext;
    class Single_gate_with_three_parameter_typeContext;
    class Single_gate_with_two_parameter_declarationContext;
    class Single_gate_with_two_parameter_typeContext;
    class Single_gate_without_parameter_declarationContext;
    class Single_gate_without_parameter_typeContext;
    class StatementContext;
    class TranslationunitContext;
    class Triple_gate_without_parameter_declarationContext;
    class Triple_gate_without_parameter_typeContext;
    class Unary_expressionContext;

    // construction

    originirParser(antlr4::TokenStream* input);

    // methods

    virtual std::string getGrammarFileName() const;
    virtual const antlr4::atn::ATN& getATN() const;
    virtual const std::vector<std::string>& getTokenNames() const;
    virtual const std::vector<std::string>& getRuleNames() const;
    virtual antlr4::dfa::Vocabulary& getVocabulary() const;
    TranslationunitContext* translationunit();
    DeclarationContext* declaration();
    Qinit_declarationContext* qinit_declaration();
    Cinit_declarationContext* cinit_declaration();
    Quantum_gate_declarationContext* quantum_gate_declaration();
    IndexContext* index();
    C_KEY_declarationContext* c_KEY_declaration();
    Q_KEY_declarationContext* q_KEY_declaration();
    Single_gate_without_parameter_declarationContext* single_gate_without_parameter_declaration();
    Single_gate_with_one_parameter_declarationContext* single_gate_with_one_parameter_declaration();
    Single_gate_with_two_parameter_declarationContext* single_gate_with_two_parameter_declaration();
    Single_gate_with_three_parameter_declarationContext* single_gate_with_three_parameter_declaration();
    Single_gate_with_four_parameter_declarationContext* single_gate_with_four_parameter_declaration();
    Double_gate_without_parameter_declarationContext* double_gate_without_parameter_declaration();
    Double_gate_with_one_parameter_declarationContext* double_gate_with_one_parameter_declaration();
    Double_gate_with_four_parameter_declarationContext* double_gate_with_four_parameter_declaration();
    Triple_gate_without_parameter_declarationContext* triple_gate_without_parameter_declaration();
    Define_gate_declarationContext* define_gate_declaration();
    Single_gate_without_parameter_typeContext* single_gate_without_parameter_type();
    Single_gate_with_one_parameter_typeContext* single_gate_with_one_parameter_type();
    Single_gate_with_two_parameter_typeContext* single_gate_with_two_parameter_type();
    Single_gate_with_three_parameter_typeContext* single_gate_with_three_parameter_type();
    Single_gate_with_four_parameter_typeContext* single_gate_with_four_parameter_type();
    Double_gate_without_parameter_typeContext* double_gate_without_parameter_type();
    Double_gate_with_one_parameter_typeContext* double_gate_with_one_parameter_type();
    Double_gate_with_four_parameter_typeContext* double_gate_with_four_parameter_type();
    Triple_gate_without_parameter_typeContext* triple_gate_without_parameter_type();
    Primary_expressionContext* primary_expression();
    Unary_expressionContext* unary_expression();
    Multiplicative_expressionContext* multiplicative_expression();
    Multiplicative_expressionContext* multiplicative_expression(int precedence);
    Addtive_expressionContext* addtive_expression();
    Addtive_expressionContext* addtive_expression(int precedence);
    Relational_expressionContext* relational_expression();
    Relational_expressionContext* relational_expression(int precedence);
    Equality_expressionContext* equality_expression();
    Equality_expressionContext* equality_expression(int precedence);
    Logical_and_expressionContext* logical_and_expression();
    Logical_and_expressionContext* logical_and_expression(int precedence);
    Logical_or_expressionContext* logical_or_expression();
    Logical_or_expressionContext* logical_or_expression(int precedence);
    Assignment_expressionContext* assignment_expression();
    ExpressionContext* expression();
    Controlbit_listContext* controlbit_list();
    StatementContext* statement();
    Dagger_statementContext* dagger_statement();
    Control_statementContext* control_statement();
    Qelse_statement_fragmentContext* qelse_statement_fragment();
    Qif_statementContext* qif_statement();
    Qwhile_statementContext* qwhile_statement();
    Measure_statementContext* measure_statement();
    Reset_statementContext* reset_statement();
    Barrier_statementContext* barrier_statement();
    Expression_statementContext* expression_statement();
    Define_gate_statementContext* define_gate_statement();
    ExplistContext* explist();
    ExpContext* exp();
    ExpContext* exp(int precedence);
    Gate_func_statementContext* gate_func_statement();
    IdContext* id();
    Id_listContext* id_list();
    Gate_nameContext* gate_name();
    ConstantContext* constant();

    virtual bool sempred(
        antlr4::RuleContext* _localctx,
        size_t ruleIndex,
        size_t predicateIndex
        );

    bool multiplicative_expressionSempred(
        Multiplicative_expressionContext* _localctx,
        size_t predicateIndex
        );

    bool addtive_expressionSempred(
        Addtive_expressionContext* _localctx,
        size_t predicateIndex
        );

    bool relational_expressionSempred(
        Relational_expressionContext* _localctx,
        size_t predicateIndex
        );

    bool equality_expressionSempred(
        Equality_expressionContext* _localctx,
        size_t predicateIndex
        );

    bool logical_and_expressionSempred(
        Logical_and_expressionContext* _localctx,
        size_t predicateIndex
        );

    bool logical_or_expressionSempred(
        Logical_or_expressionContext* _localctx,
        size_t predicateIndex
        );

    bool expSempred(
        ExpContext* _localctx,
        size_t predicateIndex
        );
};

class originirVisitor

Overview

This class defines an abstract visitor for a parse tree produced by originirParser. More…

#include <originirVisitor.h>

class originirVisitor: public AbstractParseTreeVisitor
{
public:
    // methods

    virtual antlrcpp::Any visitTranslationunit(originirParser::TranslationunitContext* context) = 0;
    virtual antlrcpp::Any visitDeclaration(originirParser::DeclarationContext* context) = 0;
    virtual antlrcpp::Any visitQinit_declaration(originirParser::Qinit_declarationContext* context) = 0;
    virtual antlrcpp::Any visitCinit_declaration(originirParser::Cinit_declarationContext* context) = 0;
    virtual antlrcpp::Any visitQuantum_gate_declaration(originirParser::Quantum_gate_declarationContext* context) = 0;
    virtual antlrcpp::Any visitIndex(originirParser::IndexContext* context) = 0;
    virtual antlrcpp::Any visitC_KEY_declaration(originirParser::C_KEY_declarationContext* context) = 0;
    virtual antlrcpp::Any visitQ_KEY_declaration(originirParser::Q_KEY_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_without_parameter_declaration(originirParser::Single_gate_without_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_one_parameter_declaration(originirParser::Single_gate_with_one_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_two_parameter_declaration(originirParser::Single_gate_with_two_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_three_parameter_declaration(originirParser::Single_gate_with_three_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_four_parameter_declaration(originirParser::Single_gate_with_four_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_without_parameter_declaration(originirParser::Double_gate_without_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_with_one_parameter_declaration(originirParser::Double_gate_with_one_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_with_four_parameter_declaration(originirParser::Double_gate_with_four_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitTriple_gate_without_parameter_declaration(originirParser::Triple_gate_without_parameter_declarationContext* context) = 0;
    virtual antlrcpp::Any visitDefine_gate_declaration(originirParser::Define_gate_declarationContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_without_parameter_type(originirParser::Single_gate_without_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_one_parameter_type(originirParser::Single_gate_with_one_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_two_parameter_type(originirParser::Single_gate_with_two_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_three_parameter_type(originirParser::Single_gate_with_three_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitSingle_gate_with_four_parameter_type(originirParser::Single_gate_with_four_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_without_parameter_type(originirParser::Double_gate_without_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_with_one_parameter_type(originirParser::Double_gate_with_one_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitDouble_gate_with_four_parameter_type(originirParser::Double_gate_with_four_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitTriple_gate_without_parameter_type(originirParser::Triple_gate_without_parameter_typeContext* context) = 0;
    virtual antlrcpp::Any visitPri_ckey(originirParser::Pri_ckeyContext* context) = 0;
    virtual antlrcpp::Any visitPri_cst(originirParser::Pri_cstContext* context) = 0;
    virtual antlrcpp::Any visitPri_expr(originirParser::Pri_exprContext* context) = 0;
    virtual antlrcpp::Any visitUnary_expression(originirParser::Unary_expressionContext* context) = 0;
    virtual antlrcpp::Any visitMultiplicative_expression(originirParser::Multiplicative_expressionContext* context) = 0;
    virtual antlrcpp::Any visitAddtive_expression(originirParser::Addtive_expressionContext* context) = 0;
    virtual antlrcpp::Any visitRelational_expression(originirParser::Relational_expressionContext* context) = 0;
    virtual antlrcpp::Any visitEquality_expression(originirParser::Equality_expressionContext* context) = 0;
    virtual antlrcpp::Any visitLogical_and_expression(originirParser::Logical_and_expressionContext* context) = 0;
    virtual antlrcpp::Any visitLogical_or_expression(originirParser::Logical_or_expressionContext* context) = 0;
    virtual antlrcpp::Any visitAssignment_expression(originirParser::Assignment_expressionContext* context) = 0;
    virtual antlrcpp::Any visitExpression(originirParser::ExpressionContext* context) = 0;
    virtual antlrcpp::Any visitControlbit_list(originirParser::Controlbit_listContext* context) = 0;
    virtual antlrcpp::Any visitStatement(originirParser::StatementContext* context) = 0;
    virtual antlrcpp::Any visitDagger_statement(originirParser::Dagger_statementContext* context) = 0;
    virtual antlrcpp::Any visitControl_statement(originirParser::Control_statementContext* context) = 0;
    virtual antlrcpp::Any visitQelse_statement_fragment(originirParser::Qelse_statement_fragmentContext* context) = 0;
    virtual antlrcpp::Any visitQif_if(originirParser::Qif_ifContext* context) = 0;
    virtual antlrcpp::Any visitQif_ifelse(originirParser::Qif_ifelseContext* context) = 0;
    virtual antlrcpp::Any visitQwhile_statement(originirParser::Qwhile_statementContext* context) = 0;
    virtual antlrcpp::Any visitMeasure_statement(originirParser::Measure_statementContext* context) = 0;
    virtual antlrcpp::Any visitReset_statement(originirParser::Reset_statementContext* context) = 0;
    virtual antlrcpp::Any visitBarrier_statement(originirParser::Barrier_statementContext* context) = 0;
    virtual antlrcpp::Any visitExpression_statement(originirParser::Expression_statementContext* context) = 0;
    virtual antlrcpp::Any visitDefine_gate_statement(originirParser::Define_gate_statementContext* context) = 0;
    virtual antlrcpp::Any visitExplist(originirParser::ExplistContext* context) = 0;
    virtual antlrcpp::Any visitExp(originirParser::ExpContext* context) = 0;
    virtual antlrcpp::Any visitGate_func_statement(originirParser::Gate_func_statementContext* context) = 0;
    virtual antlrcpp::Any visitId(originirParser::IdContext* context) = 0;
    virtual antlrcpp::Any visitId_list(originirParser::Id_listContext* context) = 0;
    virtual antlrcpp::Any visitGate_name(originirParser::Gate_nameContext* context) = 0;
    virtual antlrcpp::Any visitConstant(originirParser::ConstantContext* context) = 0;
};

// direct descendants

class originirBaseVisitor;

Detailed Documentation

This class defines an abstract visitor for a parse tree produced by originirParser.

Methods

virtual antlrcpp::Any visitTranslationunit(originirParser::TranslationunitContext* context) = 0

Visit parse trees produced by originirParser.

class qasmBaseVisitor

Overview

This class provides an empty implementation of qasmVisitor, which can be extended to create a visitor which only needs to handle a subset of the available methods. More…

#include <qasmBaseVisitor.h>

class qasmBaseVisitor: public qasmVisitor
{
public:
    // methods

    virtual antlrcpp::Any visitMainprogram(qasmParser::MainprogramContext* context);
    virtual antlrcpp::Any visitHead_decl(qasmParser::Head_declContext* ctx);
    virtual antlrcpp::Any visitVersion_decl(qasmParser::Version_declContext* ctx);
    virtual antlrcpp::Any visitInclude_decl(qasmParser::Include_declContext* ctx);
    virtual antlrcpp::Any visitStatement(qasmParser::StatementContext* ctx);
    virtual antlrcpp::Any visitReg_decl(qasmParser::Reg_declContext* ctx);
    virtual antlrcpp::Any visitOpaque_decl(qasmParser::Opaque_declContext* ctx);
    virtual antlrcpp::Any visitIf_decl(qasmParser::If_declContext* ctx);
    virtual antlrcpp::Any visitBarrier_decl(qasmParser::Barrier_declContext* ctx);
    virtual antlrcpp::Any visitGate_decl(qasmParser::Gate_declContext* ctx);
    virtual antlrcpp::Any visitGoplist(qasmParser::GoplistContext* ctx);
    virtual antlrcpp::Any visitBop(qasmParser::BopContext* ctx);
    virtual antlrcpp::Any visitQop(qasmParser::QopContext* ctx);
    virtual antlrcpp::Any visitUop(qasmParser::UopContext* ctx);
    virtual antlrcpp::Any visitAnylist(qasmParser::AnylistContext* ctx);
    virtual antlrcpp::Any visitIdlist(qasmParser::IdlistContext* ctx);
    virtual antlrcpp::Any visitId_index(qasmParser::Id_indexContext* ctx);
    virtual antlrcpp::Any visitArgument(qasmParser::ArgumentContext* ctx);
    virtual antlrcpp::Any visitExplist(qasmParser::ExplistContext* ctx);
    virtual antlrcpp::Any visitExp(qasmParser::ExpContext* ctx);
    virtual antlrcpp::Any visitId(qasmParser::IdContext* ctx);
    virtual antlrcpp::Any visitReal(qasmParser::RealContext* ctx);
    virtual antlrcpp::Any visitInteger(qasmParser::IntegerContext* ctx);
    virtual antlrcpp::Any visitDecimal(qasmParser::DecimalContext* ctx);
    virtual antlrcpp::Any visitFilename(qasmParser::FilenameContext* ctx);
};

// direct descendants

class QASMToQProg;

Inherited Members

public:
    // methods

    virtual antlrcpp::Any visitMainprogram(qasmParser::MainprogramContext* context) = 0;
    virtual antlrcpp::Any visitHead_decl(qasmParser::Head_declContext* context) = 0;
    virtual antlrcpp::Any visitVersion_decl(qasmParser::Version_declContext* context) = 0;
    virtual antlrcpp::Any visitInclude_decl(qasmParser::Include_declContext* context) = 0;
    virtual antlrcpp::Any visitStatement(qasmParser::StatementContext* context) = 0;
    virtual antlrcpp::Any visitReg_decl(qasmParser::Reg_declContext* context) = 0;
    virtual antlrcpp::Any visitOpaque_decl(qasmParser::Opaque_declContext* context) = 0;
    virtual antlrcpp::Any visitIf_decl(qasmParser::If_declContext* context) = 0;
    virtual antlrcpp::Any visitBarrier_decl(qasmParser::Barrier_declContext* context) = 0;
    virtual antlrcpp::Any visitGate_decl(qasmParser::Gate_declContext* context) = 0;
    virtual antlrcpp::Any visitGoplist(qasmParser::GoplistContext* context) = 0;
    virtual antlrcpp::Any visitBop(qasmParser::BopContext* context) = 0;
    virtual antlrcpp::Any visitQop(qasmParser::QopContext* context) = 0;
    virtual antlrcpp::Any visitUop(qasmParser::UopContext* context) = 0;
    virtual antlrcpp::Any visitAnylist(qasmParser::AnylistContext* context) = 0;
    virtual antlrcpp::Any visitIdlist(qasmParser::IdlistContext* context) = 0;
    virtual antlrcpp::Any visitId_index(qasmParser::Id_indexContext* context) = 0;
    virtual antlrcpp::Any visitArgument(qasmParser::ArgumentContext* context) = 0;
    virtual antlrcpp::Any visitExplist(qasmParser::ExplistContext* context) = 0;
    virtual antlrcpp::Any visitExp(qasmParser::ExpContext* context) = 0;
    virtual antlrcpp::Any visitId(qasmParser::IdContext* context) = 0;
    virtual antlrcpp::Any visitReal(qasmParser::RealContext* context) = 0;
    virtual antlrcpp::Any visitInteger(qasmParser::IntegerContext* context) = 0;
    virtual antlrcpp::Any visitDecimal(qasmParser::DecimalContext* context) = 0;
    virtual antlrcpp::Any visitFilename(qasmParser::FilenameContext* context) = 0;

Detailed Documentation

This class provides an empty implementation of qasmVisitor, which can be extended to create a visitor which only needs to handle a subset of the available methods.

Methods

virtual antlrcpp::Any visitMainprogram(qasmParser::MainprogramContext* context)

Visit parse trees produced by qasmParser.

class qasmLexer

struct qasmLexer::Initializer

#include <qasmLexer.h>

class qasmLexer: public Lexer
{
public:
    // enums

    enum
    {
        OPENQASM_KEY = 1,
        INCLUDE_KEY  = 2,
        OPAQUE_KEY   = 3,
        QREG_KEY     = 4,
        CREG_KEY     = 5,
        BARRIER_KEY  = 6,
        IF_KEY       = 7,
        MEASURE_KEY  = 8,
        RESET_KEY    = 9,
        GATE_KEY     = 10,
        PI_KEY       = 11,
        U_GATE_KEY   = 12,
        CX_GATE_KEY  = 13,
        ARROW        = 14,
        EQ           = 15,
        PLUS         = 16,
        MINUS        = 17,
        MUL          = 18,
        DIV          = 19,
        COMMA        = 20,
        SEMI         = 21,
        LPAREN       = 22,
        RPAREN       = 23,
        LBRACKET     = 24,
        RBRACKET     = 25,
        LBRACE       = 26,
        RBRACE       = 27,
        DQM          = 28,
        IDENTIFIER   = 29,
        INTEGER      = 30,
        DECIMAL      = 31,
        FILENAME     = 32,
        REALEXP      = 33,
        NL           = 34,
        WS           = 35,
        LC           = 36,
    };

    // structs

    struct Initializer;

    // construction

    qasmLexer(antlr4::CharStream* input);

    // methods

    virtual std::string getGrammarFileName() const;
    virtual const std::vector<std::string>& getRuleNames() const;
    virtual const std::vector<std::string>& getChannelNames() const;
    virtual const std::vector<std::string>& getModeNames() const;
    virtual const std::vector<std::string>& getTokenNames() const;
    virtual antlr4::dfa::Vocabulary& getVocabulary() const;
    virtual const std::vector<uint16_t> getSerializedATN() const;
    virtual const antlr4::atn::ATN& getATN() const;
};

class qasmListener

This interface defines an abstract listener for a parse tree produced by qasmParser.

#include <qasmListener.h>

class qasmListener: public ParseTreeListener
{
public:
    // methods

    virtual void enterMainprogram(qasmParser::MainprogramContext* ctx) = 0;
    virtual void exitMainprogram(qasmParser::MainprogramContext* ctx) = 0;
    virtual void enterHead_decl(qasmParser::Head_declContext* ctx) = 0;
    virtual void exitHead_decl(qasmParser::Head_declContext* ctx) = 0;
    virtual void enterVersion_decl(qasmParser::Version_declContext* ctx) = 0;
    virtual void exitVersion_decl(qasmParser::Version_declContext* ctx) = 0;
    virtual void enterInclude_decl(qasmParser::Include_declContext* ctx) = 0;
    virtual void exitInclude_decl(qasmParser::Include_declContext* ctx) = 0;
    virtual void enterStatement(qasmParser::StatementContext* ctx) = 0;
    virtual void exitStatement(qasmParser::StatementContext* ctx) = 0;
    virtual void enterReg_decl(qasmParser::Reg_declContext* ctx) = 0;
    virtual void exitReg_decl(qasmParser::Reg_declContext* ctx) = 0;
    virtual void enterOpaque_decl(qasmParser::Opaque_declContext* ctx) = 0;
    virtual void exitOpaque_decl(qasmParser::Opaque_declContext* ctx) = 0;
    virtual void enterIf_decl(qasmParser::If_declContext* ctx) = 0;
    virtual void exitIf_decl(qasmParser::If_declContext* ctx) = 0;
    virtual void enterBarrier_decl(qasmParser::Barrier_declContext* ctx) = 0;
    virtual void exitBarrier_decl(qasmParser::Barrier_declContext* ctx) = 0;
    virtual void enterGate_decl(qasmParser::Gate_declContext* ctx) = 0;
    virtual void exitGate_decl(qasmParser::Gate_declContext* ctx) = 0;
    virtual void enterGoplist(qasmParser::GoplistContext* ctx) = 0;
    virtual void exitGoplist(qasmParser::GoplistContext* ctx) = 0;
    virtual void enterBop(qasmParser::BopContext* ctx) = 0;
    virtual void exitBop(qasmParser::BopContext* ctx) = 0;
    virtual void enterQop(qasmParser::QopContext* ctx) = 0;
    virtual void exitQop(qasmParser::QopContext* ctx) = 0;
    virtual void enterUop(qasmParser::UopContext* ctx) = 0;
    virtual void exitUop(qasmParser::UopContext* ctx) = 0;
    virtual void enterAnylist(qasmParser::AnylistContext* ctx) = 0;
    virtual void exitAnylist(qasmParser::AnylistContext* ctx) = 0;
    virtual void enterIdlist(qasmParser::IdlistContext* ctx) = 0;
    virtual void exitIdlist(qasmParser::IdlistContext* ctx) = 0;
    virtual void enterId_index(qasmParser::Id_indexContext* ctx) = 0;
    virtual void exitId_index(qasmParser::Id_indexContext* ctx) = 0;
    virtual void enterArgument(qasmParser::ArgumentContext* ctx) = 0;
    virtual void exitArgument(qasmParser::ArgumentContext* ctx) = 0;
    virtual void enterExplist(qasmParser::ExplistContext* ctx) = 0;
    virtual void exitExplist(qasmParser::ExplistContext* ctx) = 0;
    virtual void enterExp(qasmParser::ExpContext* ctx) = 0;
    virtual void exitExp(qasmParser::ExpContext* ctx) = 0;
    virtual void enterId(qasmParser::IdContext* ctx) = 0;
    virtual void exitId(qasmParser::IdContext* ctx) = 0;
    virtual void enterReal(qasmParser::RealContext* ctx) = 0;
    virtual void exitReal(qasmParser::RealContext* ctx) = 0;
    virtual void enterInteger(qasmParser::IntegerContext* ctx) = 0;
    virtual void exitInteger(qasmParser::IntegerContext* ctx) = 0;
    virtual void enterDecimal(qasmParser::DecimalContext* ctx) = 0;
    virtual void exitDecimal(qasmParser::DecimalContext* ctx) = 0;
    virtual void enterFilename(qasmParser::FilenameContext* ctx) = 0;
    virtual void exitFilename(qasmParser::FilenameContext* ctx) = 0;
};

class qasmParser

struct qasmParser::Initializer

class qasmParser::AnylistContext

#include <qasmParser.h>

class AnylistContext: public ParserRuleContext
{
public:
    // construction

    AnylistContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    std::vector<Id_indexContext*> id_index();
    Id_indexContext* id_index(size_t i);
    std::vector<IdContext*> id();
    IdContext* id(size_t i);
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::ArgumentContext

#include <qasmParser.h>

class ArgumentContext: public ParserRuleContext
{
public:
    // construction

    ArgumentContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    IdContext* id();
    antlr4::tree::TerminalNode* LBRACKET();
    IntegerContext* integer();
    antlr4::tree::TerminalNode* RBRACKET();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::Barrier_declContext

#include <qasmParser.h>

class Barrier_declContext: public ParserRuleContext
{
public:
    // construction

    Barrier_declContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* BARRIER_KEY();
    AnylistContext* anylist();
    antlr4::tree::TerminalNode* SEMI();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::BopContext

#include <qasmParser.h>

class BopContext: public ParserRuleContext
{
public:
    // construction

    BopContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* BARRIER_KEY();
    IdlistContext* idlist();
    antlr4::tree::TerminalNode* SEMI();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::DecimalContext

#include <qasmParser.h>

class DecimalContext: public ParserRuleContext
{
public:
    // construction

    DecimalContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* DECIMAL();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::ExpContext

#include <qasmParser.h>

class ExpContext: public ParserRuleContext
{
public:
    // construction

    ExpContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    IdContext* id();
    RealContext* real();
    DecimalContext* decimal();
    IntegerContext* integer();
    antlr4::tree::TerminalNode* PI_KEY();
    antlr4::tree::TerminalNode* LPAREN();
    std::vector<ExpContext*> exp();
    ExpContext* exp(size_t i);
    antlr4::tree::TerminalNode* RPAREN();
    antlr4::tree::TerminalNode* MINUS();
    antlr4::tree::TerminalNode* MUL();
    antlr4::tree::TerminalNode* DIV();
    antlr4::tree::TerminalNode* PLUS();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::ExplistContext

#include <qasmParser.h>

class ExplistContext: public ParserRuleContext
{
public:
    // construction

    ExplistContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    std::vector<ExpContext*> exp();
    ExpContext* exp(size_t i);
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::FilenameContext

#include <qasmParser.h>

class FilenameContext: public ParserRuleContext
{
public:
    // construction

    FilenameContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* FILENAME();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::Gate_declContext

#include <qasmParser.h>

class Gate_declContext: public ParserRuleContext
{
public:
    // construction

    Gate_declContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* GATE_KEY();
    IdContext* id();
    std::vector<IdlistContext*> idlist();
    IdlistContext* idlist(size_t i);
    antlr4::tree::TerminalNode* LBRACE();
    GoplistContext* goplist();
    antlr4::tree::TerminalNode* RBRACE();
    antlr4::tree::TerminalNode* LPAREN();
    antlr4::tree::TerminalNode* RPAREN();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::GoplistContext

#include <qasmParser.h>

class GoplistContext: public ParserRuleContext
{
public:
    // construction

    GoplistContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    std::vector<UopContext*> uop();
    UopContext* uop(size_t i);
    std::vector<BopContext*> bop();
    BopContext* bop(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::Head_declContext

#include <qasmParser.h>

class Head_declContext: public ParserRuleContext
{
public:
    // construction

    Head_declContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Version_declContext* version_decl();
    Include_declContext* include_decl();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::IdContext

#include <qasmParser.h>

class IdContext: public ParserRuleContext
{
public:
    // construction

    IdContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* IDENTIFIER();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::Id_indexContext

#include <qasmParser.h>

class Id_indexContext: public ParserRuleContext
{
public:
    // construction

    Id_indexContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    IdContext* id();
    antlr4::tree::TerminalNode* LBRACKET();
    IntegerContext* integer();
    antlr4::tree::TerminalNode* RBRACKET();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::IdlistContext

#include <qasmParser.h>

class IdlistContext: public ParserRuleContext
{
public:
    // construction

    IdlistContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    std::vector<IdContext*> id();
    IdContext* id(size_t i);
    std::vector<antlr4::tree::TerminalNode*> COMMA();
    antlr4::tree::TerminalNode* COMMA(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::If_declContext

#include <qasmParser.h>

class If_declContext: public ParserRuleContext
{
public:
    // construction

    If_declContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* IF_KEY();
    antlr4::tree::TerminalNode* LPAREN();
    IdContext* id();
    antlr4::tree::TerminalNode* EQ();
    IntegerContext* integer();
    antlr4::tree::TerminalNode* RPAREN();
    QopContext* qop();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::Include_declContext

#include <qasmParser.h>

class Include_declContext: public ParserRuleContext
{
public:
    // construction

    Include_declContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* INCLUDE_KEY();
    std::vector<antlr4::tree::TerminalNode*> DQM();
    antlr4::tree::TerminalNode* DQM(size_t i);
    FilenameContext* filename();
    antlr4::tree::TerminalNode* SEMI();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::IntegerContext

#include <qasmParser.h>

class IntegerContext: public ParserRuleContext
{
public:
    // construction

    IntegerContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* INTEGER();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::MainprogramContext

#include <qasmParser.h>

class MainprogramContext: public ParserRuleContext
{
public:
    // construction

    MainprogramContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Head_declContext* head_decl();
    std::vector<StatementContext*> statement();
    StatementContext* statement(size_t i);
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::Opaque_declContext

#include <qasmParser.h>

class Opaque_declContext: public ParserRuleContext
{
public:
    // construction

    Opaque_declContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* OPAQUE_KEY();
    IdContext* id();
    std::vector<IdlistContext*> idlist();
    IdlistContext* idlist(size_t i);
    antlr4::tree::TerminalNode* SEMI();
    antlr4::tree::TerminalNode* LPAREN();
    antlr4::tree::TerminalNode* RPAREN();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::QopContext

#include <qasmParser.h>

class QopContext: public ParserRuleContext
{
public:
    // construction

    QopContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    UopContext* uop();
    antlr4::tree::TerminalNode* MEASURE_KEY();
    std::vector<ArgumentContext*> argument();
    ArgumentContext* argument(size_t i);
    antlr4::tree::TerminalNode* ARROW();
    antlr4::tree::TerminalNode* SEMI();
    antlr4::tree::TerminalNode* RESET_KEY();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::RealContext

#include <qasmParser.h>

class RealContext: public ParserRuleContext
{
public:
    // construction

    RealContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* REALEXP();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::Reg_declContext

#include <qasmParser.h>

class Reg_declContext: public ParserRuleContext
{
public:
    // construction

    Reg_declContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* QREG_KEY();
    IdContext* id();
    antlr4::tree::TerminalNode* LBRACKET();
    IntegerContext* integer();
    antlr4::tree::TerminalNode* RBRACKET();
    antlr4::tree::TerminalNode* SEMI();
    antlr4::tree::TerminalNode* CREG_KEY();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::StatementContext

#include <qasmParser.h>

class StatementContext: public ParserRuleContext
{
public:
    // construction

    StatementContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    Reg_declContext* reg_decl();
    Gate_declContext* gate_decl();
    Opaque_declContext* opaque_decl();
    If_declContext* if_decl();
    Barrier_declContext* barrier_decl();
    QopContext* qop();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::UopContext

#include <qasmParser.h>

class UopContext: public ParserRuleContext
{
public:
    // construction

    UopContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* U_GATE_KEY();
    antlr4::tree::TerminalNode* LPAREN();
    ExplistContext* explist();
    antlr4::tree::TerminalNode* RPAREN();
    std::vector<ArgumentContext*> argument();
    ArgumentContext* argument(size_t i);
    antlr4::tree::TerminalNode* SEMI();
    antlr4::tree::TerminalNode* CX_GATE_KEY();
    antlr4::tree::TerminalNode* COMMA();
    IdContext* id();
    AnylistContext* anylist();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

class qasmParser::Version_declContext

#include <qasmParser.h>

class Version_declContext: public ParserRuleContext
{
public:
    // construction

    Version_declContext(
        antlr4::ParserRuleContext* parent,
        size_t invokingState
        );

    // methods

    virtual size_t getRuleIndex() const;
    antlr4::tree::TerminalNode* OPENQASM_KEY();
    DecimalContext* decimal();
    antlr4::tree::TerminalNode* SEMI();
    virtual void enterRule(antlr4::tree::ParseTreeListener* listener);
    virtual void exitRule(antlr4::tree::ParseTreeListener* listener);
    virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor* visitor);
};

#include <qasmParser.h>

class qasmParser: public Parser
{
public:
    // enums

    enum
    {
        OPENQASM_KEY = 1,
        INCLUDE_KEY  = 2,
        OPAQUE_KEY   = 3,
        QREG_KEY     = 4,
        CREG_KEY     = 5,
        BARRIER_KEY  = 6,
        IF_KEY       = 7,
        MEASURE_KEY  = 8,
        RESET_KEY    = 9,
        GATE_KEY     = 10,
        PI_KEY       = 11,
        U_GATE_KEY   = 12,
        CX_GATE_KEY  = 13,
        ARROW        = 14,
        EQ           = 15,
        PLUS         = 16,
        MINUS        = 17,
        MUL          = 18,
        DIV          = 19,
        COMMA        = 20,
        SEMI         = 21,
        LPAREN       = 22,
        RPAREN       = 23,
        LBRACKET     = 24,
        RBRACKET     = 25,
        LBRACE       = 26,
        RBRACE       = 27,
        DQM          = 28,
        IDENTIFIER   = 29,
        INTEGER      = 30,
        DECIMAL      = 31,
        FILENAME     = 32,
        REALEXP      = 33,
        NL           = 34,
        WS           = 35,
        LC           = 36,
    };

    enum
    {
        RuleMainprogram  = 0,
        RuleHead_decl    = 1,
        RuleVersion_decl = 2,
        RuleInclude_decl = 3,
        RuleStatement    = 4,
        RuleReg_decl     = 5,
        RuleOpaque_decl  = 6,
        RuleIf_decl      = 7,
        RuleBarrier_decl = 8,
        RuleGate_decl    = 9,
        RuleGoplist      = 10,
        RuleBop          = 11,
        RuleQop          = 12,
        RuleUop          = 13,
        RuleAnylist      = 14,
        RuleIdlist       = 15,
        RuleId_index     = 16,
        RuleArgument     = 17,
        RuleExplist      = 18,
        RuleExp          = 19,
        RuleId           = 20,
        RuleReal         = 21,
        RuleInteger      = 22,
        RuleDecimal      = 23,
        RuleFilename     = 24,
    };

    // structs

    struct Initializer;

    // classes

    class AnylistContext;
    class ArgumentContext;
    class Barrier_declContext;
    class BopContext;
    class DecimalContext;
    class ExpContext;
    class ExplistContext;
    class FilenameContext;
    class Gate_declContext;
    class GoplistContext;
    class Head_declContext;
    class IdContext;
    class Id_indexContext;
    class IdlistContext;
    class If_declContext;
    class Include_declContext;
    class IntegerContext;
    class MainprogramContext;
    class Opaque_declContext;
    class QopContext;
    class RealContext;
    class Reg_declContext;
    class StatementContext;
    class UopContext;
    class Version_declContext;

    // construction

    qasmParser(antlr4::TokenStream* input);

    // methods

    virtual std::string getGrammarFileName() const;
    virtual const antlr4::atn::ATN& getATN() const;
    virtual const std::vector<std::string>& getTokenNames() const;
    virtual const std::vector<std::string>& getRuleNames() const;
    virtual antlr4::dfa::Vocabulary& getVocabulary() const;
    MainprogramContext* mainprogram();
    Head_declContext* head_decl();
    Version_declContext* version_decl();
    Include_declContext* include_decl();
    StatementContext* statement();
    Reg_declContext* reg_decl();
    Opaque_declContext* opaque_decl();
    If_declContext* if_decl();
    Barrier_declContext* barrier_decl();
    Gate_declContext* gate_decl();
    GoplistContext* goplist();
    BopContext* bop();
    QopContext* qop();
    UopContext* uop();
    AnylistContext* anylist();
    IdlistContext* idlist();
    Id_indexContext* id_index();
    ArgumentContext* argument();
    ExplistContext* explist();
    ExpContext* exp();
    ExpContext* exp(int precedence);
    IdContext* id();
    RealContext* real();
    IntegerContext* integer();
    DecimalContext* decimal();
    FilenameContext* filename();

    virtual bool sempred(
        antlr4::RuleContext* _localctx,
        size_t ruleIndex,
        size_t predicateIndex
        );

    bool expSempred(
        ExpContext* _localctx,
        size_t predicateIndex
        );
};

class qasmVisitor

Overview

This class defines an abstract visitor for a parse tree produced by qasmParser. More…

#include <qasmVisitor.h>

class qasmVisitor: public AbstractParseTreeVisitor
{
public:
    // methods

    virtual antlrcpp::Any visitMainprogram(qasmParser::MainprogramContext* context) = 0;
    virtual antlrcpp::Any visitHead_decl(qasmParser::Head_declContext* context) = 0;
    virtual antlrcpp::Any visitVersion_decl(qasmParser::Version_declContext* context) = 0;
    virtual antlrcpp::Any visitInclude_decl(qasmParser::Include_declContext* context) = 0;
    virtual antlrcpp::Any visitStatement(qasmParser::StatementContext* context) = 0;
    virtual antlrcpp::Any visitReg_decl(qasmParser::Reg_declContext* context) = 0;
    virtual antlrcpp::Any visitOpaque_decl(qasmParser::Opaque_declContext* context) = 0;
    virtual antlrcpp::Any visitIf_decl(qasmParser::If_declContext* context) = 0;
    virtual antlrcpp::Any visitBarrier_decl(qasmParser::Barrier_declContext* context) = 0;
    virtual antlrcpp::Any visitGate_decl(qasmParser::Gate_declContext* context) = 0;
    virtual antlrcpp::Any visitGoplist(qasmParser::GoplistContext* context) = 0;
    virtual antlrcpp::Any visitBop(qasmParser::BopContext* context) = 0;
    virtual antlrcpp::Any visitQop(qasmParser::QopContext* context) = 0;
    virtual antlrcpp::Any visitUop(qasmParser::UopContext* context) = 0;
    virtual antlrcpp::Any visitAnylist(qasmParser::AnylistContext* context) = 0;
    virtual antlrcpp::Any visitIdlist(qasmParser::IdlistContext* context) = 0;
    virtual antlrcpp::Any visitId_index(qasmParser::Id_indexContext* context) = 0;
    virtual antlrcpp::Any visitArgument(qasmParser::ArgumentContext* context) = 0;
    virtual antlrcpp::Any visitExplist(qasmParser::ExplistContext* context) = 0;
    virtual antlrcpp::Any visitExp(qasmParser::ExpContext* context) = 0;
    virtual antlrcpp::Any visitId(qasmParser::IdContext* context) = 0;
    virtual antlrcpp::Any visitReal(qasmParser::RealContext* context) = 0;
    virtual antlrcpp::Any visitInteger(qasmParser::IntegerContext* context) = 0;
    virtual antlrcpp::Any visitDecimal(qasmParser::DecimalContext* context) = 0;
    virtual antlrcpp::Any visitFilename(qasmParser::FilenameContext* context) = 0;
};

// direct descendants

class qasmBaseVisitor;

Detailed Documentation

This class defines an abstract visitor for a parse tree produced by qasmParser.

Methods

virtual antlrcpp::Any visitMainprogram(qasmParser::MainprogramContext* context) = 0

Visit parse trees produced by qasmParser.

Overview

// namespaces

namespace Base64;
namespace Eigen;
namespace GATEGPU;
namespace QGATE_SPACE;
namespace QPanda;
    namespace QPanda::DRAW_TEXT_PIC;
    namespace QPanda::Variational;
namespace gpu;
namespace std;

// typedefs

typedef std::map<std::string, std::map<std::string, uint32_t>> config_map;
typedef double qstate_type;
typedef std::complex<qstate_type> qcomplex_t;
typedef std::vector<qcomplex_t> QStat;
typedef std::vector<size_t> Qnum;
typedef std::vector<double> prob_vec;
typedef std::unordered_map<std::string, qstate_type> prob_map;
typedef std::unordered_map<std::string, qcomplex_t> stat_map;
typedef std::map<std::string, double> prob_dict;
typedef std::vector<std::pair<size_t, double>> prob_tuple;
typedef std::shared_ptr<QPanda::QNode> QNodeRef;
typedef wide_integer::generic_template::uint128_t uint128_t;
typedef wide_integer::generic_template::uint256_t uint256_t;
typedef wide_integer::generic_template::uint512_t uint512_t;
typedef size_t gpu_qsize_t;
typedef float gpu_qstate_t;
typedef std::complex<gpu_qstate_t> gpu_qcomplex_t;
typedef std::pair<size_t, double> gpu_pair;
typedef std::vector<gpu_pair> touple_prob;
typedef std::vector<double> vec_prob;
typedef std::vector<gpu_qsize_t> Qnum;
typedef Eigen::Matrix<qstate_type, Eigen::Dynamic, 1> rvector_t;
typedef Eigen::Matrix<qcomplex_t, Eigen::Dynamic, 1> cvector_t;
typedef Eigen::Matrix<qcomplex_t, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> cmatrix_t;
typedef std::vector<QStat> NoiseOp;

typedef bool (*noise_mode_function)(
    rapidjson::Value &,
    NoiseOp &
    );

typedef std::vector<QGateParam> vQParam;
typedef size_t vertex_index_t;
typedef std::vector<vertex_index_t> adj_arr_t;
typedef std::map<vertex_index_t, adj_arr_t> graph_data_t;
typedef float qdata_t;
typedef size_t qsize_t;
typedef std::complex<qdata_t> qcomplex_data_t;
typedef std::vector<qcomplex_data_t> qstate_t;
typedef std::vector<std::pair<size_t, bool>> qprog_sequence_t;
typedef std::vector<std::pair<qsize_t, qsize_t>> qubit_vector_t;
typedef std::map<size_t, Edge> edge_map_t;
typedef std::map<qsize_t, Vertice> vertice_map_t;
typedef std::vector<vertice_map_t> vertice_matrix_t;
typedef struct QubitVertice qubit_vertice_t;

// enums

enum ComputeBackend;
enum GateType;
enum MetadataGateType;
enum NOISE_MODEL;
enum NodeType;
enum OperatorType;
enum Operatortype;
enum QError;

// structs

struct Complex;
struct QGateParam;
struct QubitVertice;

// classes

class AbstractComplexTensor;
class AbstractDistributedFullAmplitudeEngine;
class AbstractQuantumGates;
class CPUComplexTensor;
class CPUImplQPU;
class CPUImplQPUSingleThread;
class CPUImplQPUSingleThreadWithOracle;
class CPUImplQPUWithOracle;
class ComplexTensor;
class DefaultRandomEngine;
class DeleteUnitQnode;
class DistributedFullAmplitudeEngine;
class DoubleGateNoiseModeMap;
class Edge;
class Instructions;
class MPS_Tensor;
class MeasureQVMType;
class NoisyCPUImplQPU;
class NoisyQuantum;
class QPUImpl;
class QProgMap;
class QuantumError;
class QuickBB;
class RandomEngine;
class RandomEngine19937;
class ReadLock;
class SharedMutex;
class SingleGateNoiseModeMap;
class TensorEngine;
class Vertice;
class VerticeMatrix;
class WriteLock;
class XC_RandomEngine16807;
class originirBaseVisitor;
class originirLexer;
class originirListener;
class originirParser;
class originirVisitor;
class qasmBaseVisitor;
class qasmLexer;
class qasmListener;
class qasmParser;
class qasmVisitor;

// global variables

const qstate_type PI = 3.14159265358979323846;
constexpr qstate_type SQRT2 = 1.4142135623731;
const gpu_qsize_t kThreadDim = 1024;

// global functions

uint32_t LOAD(
    uint32_t rs1,
    uint32_t rd,
    uint32_t imm
    );

uint32_t STORE(
    uint32_t rs1,
    uint32_t rd,
    uint32_t imm
    );

uint32_t BEQ(
    uint32_t rs1,
    uint32_t rs2,
    uint32_t imm
    );

uint32_t BNE(
    uint32_t rs1,
    uint32_t rs2,
    uint32_t imm
    );

uint32_t BLT(
    uint32_t rs1,
    uint32_t rs2,
    uint32_t imm
    );

uint32_t BGT(
    uint32_t rs1,
    uint32_t rs2,
    uint32_t imm
    );

uint32_t ADDI(
    uint32_t rs1,
    uint32_t rd,
    uint32_t imm
    );

uint32_t ANDI(
    uint32_t rs1,
    uint32_t rd,
    uint32_t imm
    );

uint32_t XORI(
    uint32_t rs1,
    uint32_t rd,
    uint32_t imm
    );

uint32_t ORI(
    uint32_t rs1,
    uint32_t rd,
    uint32_t imm
    );

uint32_t ADD(
    uint32_t rs1,
    uint32_t rs2,
    uint32_t rd
    );

uint32_t AND(
    uint32_t rs1,
    uint32_t rs2,
    uint32_t rd
    );

uint32_t XOR(
    uint32_t rs1,
    uint32_t rs2,
    uint32_t rd
    );

uint32_t OR(
    uint32_t rs1,
    uint32_t rs2,
    uint32_t rd
    );

uint32_t QWAITI(uint32_t imm);

uint32_t FMR(
    uint32_t rs1,
    uint32_t rd
    );

uint32_t SMIS(
    uint32_t rd,
    uint32_t imm
    );

uint32_t QI(
    uint32_t rs1,
    uint32_t rs2,
    uint32_t pi,
    uint32_t opcode1,
    uint32_t opcode2
    );

uint32_t MEASURE(
    uint32_t rs1,
    uint32_t pi
    );

std::string _file_name(const char* file = "");

template <typename UnsignedIntegralType>
std::string integerToBinary(
    const UnsignedIntegralType& number,
    int ret_len
    );

template <typename UnsignedIntegralType>
std::string integerToString(const UnsignedIntegralType& number);

template <typename UnsignedIntegralType>
UnsignedIntegralType getDecIndex(
    const UnsignedIntegralType& num1,
    const UnsignedIntegralType& num2,
    std::vector<size_t> qvec,
    size_t len
    );

QStat matrix_multiply(
    const QStat& matrix_left,
    const QStat& matrix_right
    );

QStat matrix_tensor(
    const QStat& matrix_left,
    const QStat& matrix_right
    );

bool equal(
    const QStat& lhs,
    const QStat& rhs
    );

bool damping_kraus_operator (
    rapidjson::Value&,
    NoiseOp& noise
    );

bool dephasing_kraus_operator (
    rapidjson::Value&,
    NoiseOp& noise
    );

bool decoherence_kraus_operator (
    rapidjson::Value&,
    NoiseOp& noise
    );

bool double_damping_kraus_operator (
    rapidjson::Value&,
    NoiseOp& noise
    );

bool double_decoherence_kraus_operator (
    rapidjson::Value&,
    NoiseOp& noise
    );

bool pauli_kraus_map(
    rapidjson::Value&,
    NoiseOp& noise
    );

bool decoherence_kraus_operator_p1_p2 (
    rapidjson::Value& value,
    NoiseOp& noise
    );

bool bitflip_kraus_operator (
    rapidjson::Value& value,
    NoiseOp& noise
    );

bool depolarizing_kraus_operator (
    rapidjson::Value& value,
    NoiseOp& noise
    );

bool bit_phase_flip_operator (rapidjson::Value& value, NoiseOp& noise);
bool phase_damping_oprator(rapidjson::Value& value, NoiseOp& noise);

bool double_decoherence_kraus_operator_p1_p2 (
    rapidjson::Value& value,
    NoiseOp& noise
    );

bool double_bitflip_kraus_operator (
    rapidjson::Value& value,
    NoiseOp& noise
    );

bool double_depolarizing_kraus_operator (
    rapidjson::Value& value,
    NoiseOp& noise
    );

bool double_bit_phase_flip_operator (rapidjson::Value& value, NoiseOp& noise);
bool double_phase_damping_oprator(rapidjson::Value& value, NoiseOp& noise);

bool kraus_matrix_oprator(
    rapidjson::Value& value,
    NoiseOp& noise
    );

double _default_random_generator();

double random_generator19937(
    double begine = 0,
    double end = 1
    );

void H_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void T_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void S_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void X_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void Y_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void Z_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void X1_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void Y1_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void Z1_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void RX_Gate(
    qstate_t& gate_tensor,
    double angle,
    bool isDagger
    );

void RY_Gate(
    qstate_t& gate_tensor,
    double angle,
    bool isDagger
    );

void RZ_Gate(
    qstate_t& gate_tensor,
    double angle,
    bool isDagger
    );

void U1_Gate(
    qstate_t& gate_tensor,
    double angle,
    bool isDagger
    );

void U2_Gate(
    qstate_t& gate_tensor,
    double phi,
    double lambda,
    bool isDagger
    );

void U3_Gate(
    qstate_t& gate_tensor,
    double theta,
    double phi,
    double lambda,
    bool isDagger
    );

void U4_Gate(
    qstate_t& gate_tensor,
    double alpha,
    double beta,
    double gamma,
    double delta,
    bool isDagger
    );

void CZ_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void CNOT_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void ISWAP_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void SQISWAP_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void SWAP_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

void CR_Gate(
    qstate_t& gate_tensor,
    double angle,
    bool isDagger
    );

void TOFFOLI_Gate(
    qstate_t& gate_tensor,
    bool isDagger
    );

DLLEXPORT ChemiQ* initialize(char* dir);
DLLEXPORT void finalize(ChemiQ* chemiq);
DLLEXPORT void setMolecule(ChemiQ* chemiq, char* molecule);
DLLEXPORT void setMolecules(ChemiQ* chemiq, char* molecules);
DLLEXPORT void setMultiplicity(ChemiQ* chemiq, int multiplicity);
DLLEXPORT void setCharge(ChemiQ* chemiq, int charge);
DLLEXPORT void setBasis(ChemiQ* chemiq, char* basis);
DLLEXPORT void setEqTolerance(ChemiQ* chemiq, double val);
DLLEXPORT void setTransformType(ChemiQ* chemiq, int type);
DLLEXPORT void setUccType(ChemiQ* chemiq, int type);
DLLEXPORT void setOptimizerType(ChemiQ* chemiq, int type);
DLLEXPORT void setOptimizerIterNum(ChemiQ* chemiq, int value);
DLLEXPORT void setOptimizerFuncCallNum(ChemiQ* chemiq, int value);
DLLEXPORT void setOptimizerXatol(ChemiQ* chemiq, double value);
DLLEXPORT void setOptimizerFatol(ChemiQ* chemiq, double value);
DLLEXPORT void setLearningRate(ChemiQ* chemiq, double value);
DLLEXPORT void setEvolutionTime(ChemiQ* chemiq, double value);
DLLEXPORT void setHamiltonianSimulationSlices(ChemiQ* chemiq, int value);
DLLEXPORT void setSaveDataDir(ChemiQ* chemiq, char* dir);
DLLEXPORT int getQubitsNum(ChemiQ* chemiq);
DLLEXPORT bool exec(ChemiQ* chemiq);
const DLLEXPORT char* getLastError(ChemiQ* chemiq);

// macros

#define ANGLE_VAR_BASE
#define COMPENSATE_ANGLE
#define CONFIG_PATH
#define CONST_GATE(NAME)
#define CONTROL_CONST_GATE(NAME)
#define CONTROL_SINGLE_ANGLE_GATE(NAME)
#define DECL_ANGLE_GATE_MATRIX(NAME)
#define DECL_GATE_MATRIX(NAME)
#define DEFAULT_THREAD_CNT
#define DOUBLE_GATE_TIME
#define DoubleGateMatrixSize
#define GATE_BARRIER
#define GATE_CNOT
#define GATE_CPHASE
#define GATE_CU
#define GATE_CZ
#define GATE_ECHO
#define GATE_H
#define GATE_I
#define GATE_ISWAP
#define GATE_ISWAPTheta
#define GATE_QDoubleGate
#define GATE_RPHI
#define GATE_RX
#define GATE_RY
#define GATE_RZ
#define GATE_S
#define GATE_SQISWAP
#define GATE_SWAP
#define GATE_T
#define GATE_TYPE_MEASURE
#define GATE_TYPE_READOUT
#define GATE_TYPE_RESET
#define GATE_U1
#define GATE_U2
#define GATE_U3
#define GATE_U4
#define GATE_X
#define GATE_X1
#define GATE_Y
#define GATE_Y1
#define GATE_Z
#define GATE_Z1
#define HIGH_FREQUENCY_QUBIT
#define INF
#define INF
#define INF
#define KMETADATA_GATE_TYPE_COUNT
#define MACRO_GET_GATETYPE(name)
#define MAX_COMPARE_PRECISION
#define MAX_LAYER
#define MAX_THREADS
#define PI
#define PI
#define PI
#define PI
#define PI
#define PRINT_TRACE
#define PRINT_TRACE
#define PRINT_TRACE
#define PRINT_TRACE
#define PRINT_TRACE
#define PRINT_TRACE
#define QCERR(x)

#define QCERR_AND_THROW( \
    std_exception, \
    _Message_ \
    )

#define QCERR_AND_THROW_ERRSTR( \
    std_exception, \
    x \
    )

#define QCIRCUIT_OPTIMIZER
#define QIF_REGISTER(className)

#define QPANDA_ASSERT( \
    con, \
    argv \
    )

#define QPANDA_BEGIN
#define QPANDA_END
#define QPANDA_MAJOR_VERSION
#define QPANDA_MINOR_VERSION

#define QPANDA_OP( \
    con, \
    op \
    )

#define QPANDA_PATCH_VERSION

#define QPANDA_RETURN( \
    con, \
    value \
    )

#define QUBIT_ADJACENT_MATRIX
#define QWHILE_REGISTER(className)

#define REGISTER_ANGLE_GATE_MATRIX( \
    NAME, \
    Nx, \
    Ny, \
    Nz \
    )

#define REGISTER_CBIT_NAME_(classname)
#define REGISTER_CEXPR(classname)
#define REGISTER_CLASSICAL_PROGRAM(className)
#define REGISTER_CMEM_SIZE_(classname)

#define REGISTER_GATE_MATRIX( \
    NAME, \
    U00, \
    U01, \
    U10, \
    U11 \
    )

#define REGISTER_MEASURE(className)
#define REGISTER_PHYSICAL_QUBIT(classname)
#define REGISTER_QCIRCUIT(className)
#define REGISTER_QPROGRAM(className)
#define REGISTER_QRES_NAME(classname)
#define REGISTER_QUANTUM_MACHINE(classname)
#define REGISTER_QUBIT(classname)
#define REGISTER_QUBIT_POOL_SIZE_(classname)
#define REGISTER_RESET(className)
#define SAFE_DELETE_PTR(p)
#define SINGLETON_DECLARE(Type)
#define SINGLETON_IMPLEMENT_EAGER(Type)
#define SINGLETON_IMPLEMENT_LAZY(Type)
#define SINGLE_ANGLE_GATE(NAME)
#define SINGLE_GATE_TIME
#define SQ2
#define SQ2
#define SQ2
#define SWAP_TIME
#define SingleGateMatrixSize
#define UNDEF_DOUBLE
#define USING_QPANDA
#define VIRTUAL_Z_CONFIG
#define ZeroJudgement
#define _DOUBLE_ANGLE_GATE(NAME)
#define _DOUBLE_GATE(NAME)
#define _SINGLE_ANGLE_GATE(NAME)
#define _SINGLE_GATE(NAME)
#define _TRIPLE_GATE(NAME)
#define __FILENAME__

#define const_single_qubit_gate( \
    GATE_NAME, \
    qn, \
    isConjugate, \
    error_rate \
    )

#define control_const_single_qubit_gate( \
    GATE_NAME, \
    qn, \
    vControlBit, \
    isConjugate, \
    error_rate \
    )

#define control_single_qubit_angle_gate( \
    GATE_NAME, \
    qn, \
    theta, \
    vControlBit, \
    isConjugate, \
    error_rate \
    )

#define iunit

#define single_qubit_angle_gate( \
    GATE_NAME, \
    qn, \
    theta, \
    isConjugate, \
    error_rate \
    )

Detailed Documentation

Global Variables

const qstate_type PI = 3.14159265358979323846

Square root of two

Global Functions

template <typename UnsignedIntegralType>
std::string integerToBinary(
    const UnsignedIntegralType& number,
    int ret_len
    )

Unsigned integer to binary string.

Parameters:

const	UnsignedIntegralType & number
int	binary string length

Returns:

std::string unsigned integer string

template <typename UnsignedIntegralType>
std::string integerToString(const UnsignedIntegralType& number)

Unsigned integer to binary string.

Parameters:

const

UnsignedIntegralType & number

Returns:

std::string unsigned integer string

template <typename UnsignedIntegralType>
UnsignedIntegralType getDecIndex(
    const UnsignedIntegralType& num1,
    const UnsignedIntegralType& num2,
    std::vector<size_t> qvec,
    size_t len
    )

Get quantum state dec index in pmeasure.

Parameters:

const	UnsignedIntegralType & num1
const	UnsignedIntegralType & num2
std::vector<size_t>	qvec
size_t	binary string length

Returns:

Unsigned Integral Type

DLLEXPORT ChemiQ* initialize(char* dir)

Initialize the quantum chemistry calculation.

Parameters:

std::string

The dir of the psi4 chemistry calculation package

Returns:

ChemiQ* a ChemiQ object ptr

DLLEXPORT void finalize(ChemiQ* chemiq)

Finalize the quantum chemistry calculation.

Parameters:

ChemiQ*

the ChemiQ object ptr will be finalized

DLLEXPORT void setMolecule(ChemiQ* chemiq, char* molecule)

Set the molecular model to calculate.

Parameters:

ChemiQ*	the target ChemiQ object ptr
std::string	molecule model

DLLEXPORT void setMolecules(ChemiQ* chemiq, char* molecules)

Set the molecular model to calculate.

Parameters:

ChemiQ*	the target ChemiQ object ptr
char*	the molecules ptr

DLLEXPORT void setMultiplicity(ChemiQ* chemiq, int multiplicity)

Set the multiplicity of the molecular model.

Parameters:

ChemiQ*	the target ChemiQ object ptr
int	multiplicity

DLLEXPORT void setCharge(ChemiQ* chemiq, int charge)

Set the charge of the molecular model.

Parameters:

ChemiQ*	the target ChemiQ object ptr
int	charge

DLLEXPORT void setBasis(ChemiQ* chemiq, char* basis)

Set the calculation basis.

Parameters:

ChemiQ*	the target ChemiQ object ptr
std::string	basis

DLLEXPORT void setEqTolerance(ChemiQ* chemiq, double val)

Set Eq Tolerance.

Parameters:

ChemiQ*	the target ChemiQ object ptr
double	EqTolerance value

DLLEXPORT void setTransformType(ChemiQ* chemiq, int type)

Set the transform type from Fermion operator to Pauli operator.

Parameters:

ChemiQ*	the target ChemiQ object ptr
int	transform type

See also:

QPanda::TransFormType

DLLEXPORT void setUccType(ChemiQ* chemiq, int type)

Set the ucc type to contruct the Fermion operator.

Parameters:

ChemiQ*	the target ChemiQ object ptr
int	ucc type

See also:

QPanda::UccType

DLLEXPORT void setOptimizerType(ChemiQ* chemiq, int type)

Set the optimizer type.

Parameters:

ChemiQ*	the target ChemiQ object ptr
int	optimizer type

See also:

QPanda::OptimizerType

DLLEXPORT void setOptimizerIterNum(ChemiQ* chemiq, int value)

Set the optimizer iteration number.

Parameters:

ChemiQ*	the target ChemiQ object ptr
size_t	iteration number

DLLEXPORT void setOptimizerFuncCallNum(ChemiQ* chemiq, int value)

Set the optimizer function callback number.

Parameters:

ChemiQ*	the target ChemiQ object ptr
size_t	function callback number

DLLEXPORT void setOptimizerXatol(ChemiQ* chemiq, double value)

Set the optimizer iteration number.

Parameters:

ChemiQ*	the target ChemiQ object ptr
size_t	iteration number

DLLEXPORT void setOptimizerFatol(ChemiQ* chemiq, double value)

Set the optimizer fatol.It is the Absolute error in func(xopt) between iterations that is acceptable for convergence.

Parameters:

ChemiQ*	the target ChemiQ object ptr
double	absolute error between func(xopt)

DLLEXPORT void setLearningRate(ChemiQ* chemiq, double value)

Set the learing rate when using Gradient optimizer.

Parameters:

ChemiQ*	the target ChemiQ object ptr
double	learing rate

DLLEXPORT void setEvolutionTime(ChemiQ* chemiq, double value)

Set the evolution time when doing hamiltonian simulation.

Parameters:

ChemiQ*	the target ChemiQ object ptr
double	evolution time

DLLEXPORT void setHamiltonianSimulationSlices(ChemiQ* chemiq, int value)

Set the hamiltonian simulation slices (e^iAt/n*e^iBt/n)^n, n is the slices.

Parameters:

ChemiQ*	the target ChemiQ object ptr
double	hamiltonian simulation slices

DLLEXPORT void setSaveDataDir(ChemiQ* chemiq, char* dir)

Set the directory to save the calculated data. If it’s a not exist dir data will not be saved.

Parameters:

ChemiQ*	the target ChemiQ object ptr
std::string	dir

DLLEXPORT int getQubitsNum(ChemiQ* chemiq)

get qubits num with the above config.

Parameters:

ChemiQ*

the target ChemiQ object ptr

Returns:

int -1:means failed.

DLLEXPORT bool exec(ChemiQ* chemiq)

exec molecule calculate.

Parameters:

ChemiQ*

the target ChemiQ object ptr

Returns:

bool true:success; false:failed

const DLLEXPORT char* getLastError(ChemiQ* chemiq)

get last error.

Parameters:

ChemiQ*

the target ChemiQ object ptr

Returns:

char* last error

Macros

#define QCERR(x)

QPanda2 cout error message.

#define QCERR_AND_THROW_ERRSTR(std_exception, x)

output the error string to standard error and throw a standard exception. A standard exception can be of the following types: runtime_error, invalid_argument, range_error, etc

Global Namespace

Index