//对几种比较耗时的计算的时间统计：
/*
#include <pbc.h>
#include <pbc_test.h>
#include <iostream>
using namespace std;
//#define  F_PATH "e:\\libpbc\\param\\a.param"//对type a曲线的计算
//#define  F_PATH "e:\\libpbc\\param\\a.param"//对type a曲线的计算
#define  F_PATH "e:\\libpbc\\param\\a.param"//对type a曲线的计算
int main(int argc, char** argv)
{
	
	pairing_t pairing;
	pbc_demo_pairing_init(pairing, F_PATH);
	if (!pairing_is_symmetric(pairing)) pbc_die("pairing must be symmetric");

	clock_t starttime1, endtime1, starttime2,endtime2, starttime3, endtime3, starttime4, endtime4, starttime5, endtime5, starttime6, endtime6, starttime7, endtime7;

	element_t P, Q, R, a, b, c, gt;
	element_init_Zr(a, pairing);//初始化a为环上的元素
	element_init_Zr(b, pairing);//初始化b为环上的元素
	element_init_Zr(c, pairing);//初始化c为环上的元素

	//G1×G2→GT：我们发现下面只有对群G1的初始化，说明我们使用的是对称的，也就是 G2=G1 ===只要没有出现对G2的初始化操作，就可以断定是对称双线性对
	element_init_G1(P, pairing);
	element_init_G1(Q, pairing);
	element_init_G1(R, pairing);

	element_init_GT(gt, pairing);

	//element_random(gt);
	//element_printf("%B",gt);

	printf("computation cost as follow....\n");//printf函数：在控制台打印数据
	printf("\n\n\npairing计算\n");
	//不需要预处理，因此要的就是每次计算不同的P,Q的pairing耗时
	//pairing_pp_t pp1;
	//pairing_pp_t pp2;
	//element_random(P);
	//element_random(Q);
	//pairing_pp_init(pp1, P, pairing); // x is some element of G1
	//pairing_pp_init(pp2, Q, pairing);
	//pairing_pp_apply(r1, y1, pp); // r1 = e(x, y1)
	//pairing_pp_apply(r2, y2, pp); // r2 = e(x, y2)
	//pairing_pp_clear(pp); // don't need pp anymore
	//double starttime1 = pbc_get_time();//开始计时

	starttime1 = clock(); endtime1 = clock();
	for (size_t i = 0; i < 10000; i++)
	{
		element_random(P);
		element_random(Q);
		pairing_apply(gt, P, Q, pairing);
		//element_pairing(gt, P, Q);
	}
	endtime1 = clock();
	//double endtime1 = pbc_get_time();
	//cout << endtime1 - starttime1<< "毫秒" << endl;这个输出函数速度太慢
	printf("万次pairing计算平均耗时：%.3f毫秒\n", 1.0*(endtime1 - starttime1) / 10000);


	printf("\n\n\n加法群G指数计算\n");
	//double starttime2 = pbc_get_time();//开始计时
	starttime2 = clock();
	for (size_t i = 0; i < 10000; i++)
	{
		element_random(a);
		element_random(P);
		element_mul_zn(R, P, a);
	}
	endtime2 = clock();
	//double endtime2 = pbc_get_time();
	printf("万次加法群G指数计算平均耗时：%.3f毫秒\n", 1.0*(endtime2 - starttime2) / 10000);


	printf("\n\n\n乘法群GT指数计算\n");
	//不需要预处理
	//element_pp_t g_pp；
	//element_pp_init(g_pp, g);
	//element_pp_pow(h, pow1, g_pp); // h = g^pow1
	//element_pp_pow(h, pow2, g_pp); // h = g^pow2
	//element_pp_pow(h, pow3, g_pp); // h = g^pow3
	//element_pp_clear（g_pp）；
	//double starttime3 = pbc_get_time();//开始计时
	starttime3 = clock(); 
	for (size_t i = 0; i < 10000; i++)
	{
		element_random(gt);
		element_random(a);
		element_pow_zn(gt, gt, a);
	}
	endtime3 = clock();
	//double endtime3 = pbc_get_time();
	printf("万次乘法群指数计算平均耗时：%.3f毫秒\n", 1.0*(endtime3 - starttime3) / 10000);


	printf("\n\n\n加法群G点乘计算\n");
	//double starttime4 = pbc_get_time();//开始计时
	starttime4 = clock();
	for (size_t i = 0; i < 10000; i++)
	{
		element_random(P);
		element_random(Q);
		element_mul(R, P, Q);
	}
	endtime4 = clock();
	//double endtime4 = pbc_get_time();
	printf("万次加法群G点乘计算平均耗时：%.3f毫秒\n", 1.0*(endtime4 - starttime4) / 10000);


	printf("\n\n\n哈希函数计算\n");
	//double starttime5 = pbc_get_time();//开始计时
	starttime5 = clock();
	for (size_t i = 0; i < 10000; i++)
	{	//由于hash函数的输入需要根据实际情况而定，因此计算出的时间只具有参考价值
		element_from_hash(P, "Message", 7);//H=hash("Message")；==>G
	}
	endtime5 = clock();
	//double endtime5 = pbc_get_time();
	printf("万次哈希计算平均耗时：%.3f毫秒\n", 1.0*(endtime5 - starttime5) / 10000);


	printf("\n\n\n模加计算\n");//由于在有限域内的计算，在自带的代码中已经实现了模运算，因此我们只需要直接计算两个有限域元素相加，或者相乘即可
	//double starttime6 = pbc_get_time();//开始计时
	starttime6 = clock();
	for (size_t i = 0; i < 10000; i++)
	{
		element_random(a);
		element_random(b);
		element_random(c);
		element_add(c, b, a);
	}
	endtime6 = clock();
	//double endtime6 = pbc_get_time();
	printf("万次模加计算平均耗时：%.3f毫秒\n", 1.0*(endtime6 - starttime6) / 10000);


	printf("\n\n\n模乘计算\n");
	//double starttime7 = pbc_get_time();//开始计时
	starttime7 = clock();
	for (size_t i = 0; i < 10000; i++)
	{
		element_random(a);
		element_random(b);
		element_random(c);
		element_mul(c, b, a);
	}
	endtime7 = clock();
	//double endtime7 = pbc_get_time();
	printf("万次哈希计算平均耗时：%.3f毫秒\n", 1.0*(endtime7 - starttime7) / 10000);


	//特别注意，变量不再使用的时候，一定要清除变量，不然会造成内存泄漏
	element_clear(P);
	element_clear(Q);
	element_clear(R);
	element_clear(a);
	element_clear(b);
	element_clear(c);
	element_clear(gt);
	pairing_clear(pairing);

	printf("Have a good day!\n");
	std::cin.get();
	return 0;
}

*/

//clock_t start, ends;
//start = clock();

//ends = clock();
//cout << ends - start << endl;