产品概述

量子算法
用户接口
量子机器
量子程序
QPanda

量子算法 Quantum Algorithm

QPanda集成大量量子算法并提供接口,帮助您快速建立应用。用户API参考文档参见 使用文档

量子算法库

量子计算机上只能运行量子算法,我们集成了常见、常用的量子算法,避免了漫长的算法学习时间。QPanda可以让您把重心放在如何配置自己的应用上。

用户接口 User Interface

QPanda采用C++进行设计、开发。用户API参考文档参见 使用文档

合理接口设计

QPanda隐藏了实现细节,提供的接口直观、简洁,任何人都可以轻松上手。

详细接口说明

我们对常用的操作进行封装,并提供给您一套详细的API文档

量子机器模型 Quantum Machine Model

QPanda定义了适合量子计算机运行的程序模型,使得量子程序中可以动态分配释放资源。用户API参考文档参见 使用文档

静态量子机器

QPanda将量子计算机的特征进行抽象,对量子应用的创建和运行过程标准化。

量子比特池

通过对实际的量子芯片进行虚拟化,您可以通过量子比特池来申请、使用、释放量子比特。其中的额外的工作QPanda已代您完成。

量子计算机适配

担心量子计算机支持不同的指令集导致量子应用不兼容?QPanda可以帮您自动适配

量子程序 Quantum Program

QPanda使用C++的方式去构建量子程序,避免量子汇编的冗长代码。用户API参考文档参见使用文档使用文档

量子线路模块

QPanda将常见的量子线路进行了整合,省去大量重复工作。

量子控制流

您可以在QPanda中任意配置q-if和q-while的组合,轻松构建复杂的量子-经典混合程序。

QPanda Framework

QPanda Framework是由本源量子推出的量子软件开发包。使用QPanda Framework,您可以:

- 创建任何量子-经典混合应用

- 在不同的量子计算机或虚拟机后端运行量子程序

QPanda遵循Apache Licence 2.0开源协议发布到GitHub,欢迎您为我们的软件提出宝贵的意见和建议!
  • QPanda
  • 量子算法
  • 量子程序
  • 量子机器
  • 用户接口

QPanda Framework

QPanda Framework是由本源量子推出的量子软件开发包。使用QPanda Framework,您可以:

- 创建任何量子-经典混合应用

- 在不同的量子计算机或虚拟机后端运行量子程序

QPanda遵循Apache Licence 2.0开源协议发布到GitHub,欢迎您为我们的软件提出宝贵的意见和建议!

量子算法 Quantum Algorithm

QPanda集成大量量子算法并提供接口,帮助您快速建立应用。用户API参考文档参见 使用文档

量子算法库

量子计算机上只能运行量子算法,我们集成了常见、常用的量子算法,避免了漫长的算法学习时间。QPanda可以让您把重心放在如何配置自己的应用上。

量子程序 Quantum Program

QPanda使用C++的方式去构建量子程序,避免量子汇编的冗长代码。用户API参考文档参见使用文档使用文档

量子线路模块

QPanda将常见的量子线路进行了整合,省去大量重复工作。

量子控制流

您可以在QPanda中任意配置q-if和q-while的组合,轻松构建复杂的量子-经典混合程序。

量子机器模型 Quantum Machine Model

QPanda定义了适合量子计算机运行的程序模型,使得量子程序中可以动态分配释放资源。用户API参考文档参见 使用文档

静态量子机器

QPanda将量子计算机的特征进行抽象,对量子应用的创建和运行过程标准化。

量子比特池

通过对实际的量子芯片进行虚拟化,您可以通过量子比特池来申请、使用、释放量子比特。其中的额外的工作QPanda已代您完成。

量子计算机适配

担心量子计算机支持不同的指令集导致量子应用不兼容?QPanda可以帮您自动适配

用户接口 User Interface

QPanda采用C++进行设计、开发。用户API参考文档参见 使用文档

合理接口设计

QPanda隐藏了实现细节,提供的接口直观、简洁,任何人都可以轻松上手。

详细接口说明

我们对常用的操作进行封装,并提供给您一套详细的API文档

产品优势

支持控制流
Support Quantum Control Flow
不论q-if还是q-while,你都可以将它们任意组合,并插入到量子线路中的任何地方
轻松编写混合算法
Easy to make hybrid algorithm
利用内置的API可以轻松导入导出量子计算机中的数据,量子-经典计算机无缝衔接。
完全使用经典语言
Enable full classical language
担心学习量子语言成本太高?QPanda给你更多选择。现在,仅用C++就可以创建任何量子算法。
  • 支持控制流
    Support Quantum Control Flow
    不论q-if还是q-while,你都可以将它们任意组合,并插入到量子线路中的任何地方
  • 轻松编写混合算法
    Easy to make hybrid algorithm
    利用内置的API可以轻松导入导出量子计算机中的数据,量子-经典计算机无缝衔接。
  • 完全使用经典语言
    Enable full classical language
    担心学习量子语言成本太高?QPanda给你更多选择。现在,仅用C++就可以创建任何量子算法。

典型算法

D-J算法
快速做判断
一次见分晓
查看详情
Grover算法
神速搜目标
大数据利器
查看详情
HHL算法
解线性方程
助机器学习
查看详情
量子游戏策略
非局域游戏
博弈新世界
查看详情
查看详情
快速做判断,一次见分晓
Deutsch-Jozsa算法是人类发现的第一个量子算法,相对于经典计算机,它实现了指数加速。在经典计算机上需要遍历的数据,在量子计算机上可以进行瞬间的判断。
Deutsch-Jozsa算法用于判断一个函数是常量函数还是均衡函数。尽管Deutsch-Jozsa算法目前没有什么实际的应用,但是它使人们第一次意识到量子计算的巨大潜力……

D-J算法的参考线路图:

参考代码: 复制代码
#include "DJ_Algorithm.h"

QProg & Two_Qubit_DJ_Algorithm_Circuit(
	Qubit * qubit1, 
	Qubit * qubit2, 
	CBit * cbit, 
	vector< bool> oracle_function)

{
	auto &prog = CreateEmptyQProg();
	//Firstly, create a circuit container

	prog << H(qubit1) << H(qubit2);
	// Perform Hadamard gate on all qubits

	if (oracle_function[0] == false
		&&
		oracle_function[1] == false)
		// different oracle leads to different circuit
		// f(x) = oracle_function[x]
	{
		// f(x) = 0, do nothing
	}
	else if (oracle_function[0] == false
		&&
		oracle_function[1] == true
		)
	{
		// f(x) = x;
		prog << CNOT(qubit1, qubit2);
	}
	else if (oracle_function[0] == true
		&&
		oracle_function[1] == false
		)
	{
		// f(x) = x + 1;
		prog << RX(qubit2)
			<< CNOT(qubit1, qubit2)
			<< RX(qubit2);
	}
	else if (oracle_function[0] == true
		&&
		oracle_function[1] == true
		)
	{
		// f(x) = 1
		prog << RX(qubit2);
	}

	// Finally, Hadamard the first qubit and measure it
	prog << H(qubit1) << Measure(qubit1, cbit);
	return prog;
}
                                        
查看详情
神速搜目标,大数据利器
大数据时代,造就了大数据的恐慌,如今每天产生的数据量,是过去十年积累的总和还要多,海量数据让信息处理面临巨大挑战。
量子搜索算法对于搜索问题,做到了时间复杂度为$O(\sqrt{N})$ 在经典计算机上需要一亿次计算解决的问题,量子计算用一万次就能解决。 随着问题的增加,加速倍数还能增多,这就是量子计算的力量!

Grover算法的参考线路图:

参考代码: 复制代码
#include "Grover_Algorithm.h"

QProg& Grover(vector<Qubit*> qVec, vector<CBit*> cVec, int target)
{
    QProg & grover = CreateEmptyQProg();
    OriginQCircuit & init = CreateEmptyCircuit();
    OriginQCircuit & oracle = CreateEmptyCircuit();
    OriginQCircuit & reverse = CreateEmptyCircuit();
    init << H(qVec[0]) << H(qVec[1]) << RX(qVec[2]) << H(qVec[2]);

    vector<Qubit *> controlVector;
    controlVector.push_back(qVec[0]);
    controlVector.push_back(qVec[1]);
    //QSingleGate  sqrtH(0.5*PI, 0, 0.25*PI, PI);
    OriginQGateNode  &toff = RX(qVec[2]);
    toff.setControl(controlVector);
    switch (target)
    {
    case 0:
        oracle << RX(qVec[0]) << RX(qVec[1]) << toff << RX(qVec[0]) << RX(qVec[1]);
        break;
    case 1:
        oracle << RX(qVec[0]) << toff << RX(qVec[0]);
        break;
    case 2:
        oracle << RX(qVec[1]) << toff << RX(qVec[1]);
        break;
    case 3:
        oracle << toff;
        break;
    }
    reverse << H(qVec[0]) << H(qVec[1]) << RX(qVec[0]) << RX(qVec[1])
        << H(qVec[1]) << CNOT(qVec[0], qVec[1]);
    reverse << H(qVec[1]) << RX(qVec[0]) << RX(qVec[1]) << H(qVec[0]) << H(qVec[1]) << RX(qVec[2]);
    grover << init << oracle << reverse << Measure(qVec[0], cVec[0]) << Measure(qVec[1], cVec[1]);
    return grover;
}
                                        
查看详情
解线性方程,助机器学习
HHL算法使量子计算机求解线性方程组可以实现指数加速。
线性系统是很多科学和工程领域的核心,量子计算机未来能够在机器学习、数值计算等场景展现其巨大的计算能力。配合Grover算法在数据搜索方面的加速,量子计算机将是未来人工智能科技得以突破的关键技术。

HHL量子算法线路参考图 :

参考代码: 复制代码
#include "HHL_Algorithm.h"

QProg& hhl
(vector<Qubit*> qVec,vector<CBit*> cVec)
{
    ClassicalCondition *cc0=bind_a_cbit(cVec[0]);

	// meaningless sentence
    OriginQCircuit & ifcircuit = CreateEmptyCircuit();

    OriginQCircuit & PSEcircuit = hhlPse(qVec);//PSE
    OriginQCircuit & CRot = CRotate(qVec);//control-lambda
    OriginQCircuit & PSEcircuitdag = hhlPse(qVec);
    //hhl circuit
    QProg & PSEdagger = CreateEmptyQProg();
    PSEdagger << PSEcircuitdag.dagger() << Measure(qVec[3], cVec[1]);
    QIfNode & ifnode = CreateIfProg(cc0, &PSEdagger);
    QProg & hhlProg = CreateEmptyQProg();
    //hhlProg << PSEcircuit <<CRot<<  Measure(qVec[0], cVec[0])<<ifnode;
    hhlProg << PSEcircuit << CRot << Measure(qVec[0], cVec[0]) << ifnode;
    return hhlProg;
}
OriginQCircuit& hhlPse(vector<Qubit*> qVec)
{
    OriginQCircuit & PSEcircuit = CreateEmptyCircuit();
    PSEcircuit << H(qVec[1]) << H(qVec[2]) << RZ(qVec[2], 0.75*PI);
    OriginQGateNode & gat1 = QDouble(PI, 1.5*PI, -0.5*PI, PI / 2, qVec[2], qVec[3]);
    OriginQGateNode  & gat2 = QDouble(PI, 1.5*PI, -PI, PI / 2, qVec[1], qVec[3]);
}

                                        
查看详情
非局域游戏,博弈新世界
非局域博弈游戏(Non-local Game),也称心灵感应测试(Telepathy-testing )。该游戏是经典情况下,玩家自由意志参与游戏,通过多次的统计得出了游戏的胜利失败分布。通常情况下,玩家玩游戏的胜率不超过75%,当玩家在让量子资源融入自己的策略中时,发现能够得到更高的胜利可能,能高达85%。
这个游戏引出了很多值得探讨的问题,尤其在没有通信的前提下,从胜率75%到85%这个过程中,量子比特究竟是怎么影响到我们的现实世界的?

游戏策略的参考线路图:

参考代码: 复制代码
#include "Nonlocal_Game.h"

bool Winning_Test(pair<bool, bool> question, pair<bool, bool> answer)
{
	bool question_condition = question.first && question.second;
	bool answer_condition = answer.first || answer.second;

	if (question_condition == answer_condition)
	{
		return true; // Alice and Bob win the game.
	}
	else
	{
		return false; // Alice and Bob lose the game.
	}
}

pair<bool, bool> getRefereeQuestion()
{
	bool toAlice, toBob;
	srand(time(0));
	toAlice = static_cast<bool>(rand() % 2);
	toBob = static_cast<bool>(rand() % 2);
	// Random number simulation function is used to 
	// simulate the problem that Referee will ask Alice and Bob.
	return make_pair(toAlice, toBob);
}

QProg& Game(
	Qubit* alice_qubit,
	Qubit* bob_qubit,
	CBit* alice_meas,
	CBit* bob_meas,
	pair<bool, bool> &question)
{
	auto & game = CreateEmptyQProg();
	auto & entangled = CreateEmptyCircuit();
	auto & oracle = CreateEmptyCircuit();

	auto & Gate_I = RY(alice_qubit, 0);
	auto & Gate_T = RZ(bob_qubit, PI / 4);
	auto & Gate_T_Daga = RZ(bob_qubit, - PI / 4);
	// Custom Quantum logic Gates

	entangled << H(alice_qubit) << CNOT(bob_qubit, alice_qubit);
	// Make two qubit entangled, Here alice_qubit represent the qubit of Alice, and bob_qubit represent the qubit of bob. 
	question = getRefereeQuestion();

	if (question.first)
	{
		if (question.second)
		{
			oracle << H(alice_qubit) << S(bob_qubit) << H(bob_qubit) << Gate_T_Daga << H(bob_qubit);
		}
		else
		{
			oracle << H(alice_qubit) << S(bob_qubit) << H(bob_qubit) << Gate_T << H(bob_qubit);
		}
	}

	else
	{
		if (question.second)
		{
			oracle << Gate_I << S(bob_qubit) << H(bob_qubit) << Gate_T_Daga << H(bob_qubit);
		}
		else
		{
			oracle << Gate_I << S(bob_qubit) << H(bob_qubit) << Gate_T << H(bob_qubit);
		}
	}
	game << entangled << oracle << Measure(alice_qubit, alice_meas) << Measure(bob_qubit, bob_meas);
	return game;
}

void Nonlocal_Game(){
	size_t Round = 10;
	size_t win = 0;
	size_t lose = 0;
	for (size_t i = 0; i < Round; i++)
	{
		init();
		auto alice_qubit = qAlloc();
		auto   bob_qubit = qAlloc();
		auto  alice_meas = cAlloc();
		auto    bob_meas = cAlloc();
		pair<bool, bool> question;
		auto &GameProg = Game(alice_qubit,bob_qubit,alice_meas,bob_meas, question);
		load(GameProg);
		run();
		auto alice_answer = getCBitValue(alice_meas);
		auto   bob_answer = getCBitValue(bob_meas);
		bool final_result = Winning_Test(question, make_pair(alice_answer, bob_answer));
		if (final_result==true)
		{
			win++;
		}
		else
		{
			lose++;
		}
		cout << "The number of times player have won is;" << win;
		cout << "The number of times player have lose is;" << lose;
		finalize();

	}
}                                        

下载中心

QPanda Framework
版本:2.0
更新日期:2018-06-04
适用系统:Windows版
量子软件开发包 QPanda
版本:1.0
更新日期:2018-06-04
适用系统:Windows版