利用类实现rand函数，以及相应的优化

最新推荐文章于 2024-05-04 23:45:19 发布
最新推荐文章于 2024-05-04 23:45:19 发布
阅读量281 收藏
点赞数
分类专栏： 杂项 文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/irmae/article/details/105585926
版权

亮点：实现了一个非常高效的跳越性调用函数，见代码part 4

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
//
//
//part1.
//以下是rand类的一个简单实现。比起rand(),它的函数调用的代码更简单(参考源代码)，且：
//1.可以直接读取内态，这在某些场合下是需要用到的。
//2.通过定义不同的tprand变量，可以直接实现互不干涉的rand链。
//3.源码透明，有利于编译器做进一步优化。
/*
struct tprand
{
	unsigned long r;
	tprand(unsigned seed = 0) { r = seed; }
	int operator()(void)
	{
		return((r = r * 214013L
			+ 2531011L) >> 16) & 0x7fff;//关键链在于*链。
	}
};
*/
//part2.
//在以上的基础上，可以拓展两个功能：
//jump和哈希式tprand(ul)调用。
/*
struct tprand
{
	unsigned long r;
	tprand(unsigned seed = 0) { r = seed; }
	int operator()(void)
	{
		return((r = r * 214013L
			+ 2531011L) >> 16) & 0x7fff;
	}
	int operator()(unsigned long r)const
	{
		return ((r * 214013L
			+ 2531011L) >> 16) & 0x7fff;//竟然不能声明为static()。
	}
	int jump(int jp)//由于不涉及内存读取，【可以实现无限制循环展开。】非常tmd强！
	{
		for (int j = 0; j < jp; j++) {
			r = r * 214013L + 2531011L;
		}
		return (r >> 16) & 0x7fff;
		
	}//rand=jump(1)，jump(0)可以实现0次的操作，即获得错过的值。
};
*/
//其中：
//tprand(ul)操作提供了对应的哈希。
//tprand()=jump(1),而jump(0)可以实现"0次"操作，即获得刚刚输出的随机值。也可以用tprand(::r)来实现。
//其中经检测，(release下)【jump和普通的tprand外循环效率没有差别，可见>>16和&0x7fff不在计算的关键路径内。】
//总之，jump的效率仍旧不足。
//part3.
//考虑到计算机整数计算的两个性质：【加法和乘法满足交换律和循环率】，结合【循环展开】的思想，可以进行如下优化：
/*
int jump(int jp)//由于不涉及顺序依赖，【意识到，可以实现【无限制循环展开】！以下是普通循环展开的示例。
	{
		int i = 0;
		while (i < jp - 7)
		{
			//r = (((r * 214013L + 2531011L) * 214013L + 2531011L) * 214013L + 2531011L) * 214013L + 2531011L.......,;//【由于符合交换律和结合律】，可以看出，可以进行以下修改：
			//等价于：r = r * (214013L * 214013L * 214013L * 214013L * 214013L * 214013L * 214013L * 214013L) + (2531011L * 214013L * 214013L * 214013L * 214013L * 214013L * 214013L * 214013L + 2531011L * 214013L * 214013L * 214013L * 214013L * 214013L * 214013L + 2531011L * 214013L * 214013L * 214013L * 214013L * 214013L + 2531011L * 214013L * 214013L * 214013L * 214013L + 2531011L * 214013L * 214013L * 214013L + 2531011L * 214013L * 214013L + 2531011L * 214013L+ 2531011L);
			#if 0
			void rfuncstr(int loop)//乘k次：
			{
				long rmut = 1, radd = 0;
				for (int i = 0; i < loop; i++) {
					radd += 2531011L * rmut;
					rmut *= 214013L;
				}
				printf("r=r*(%ld)+(%ld)\n", rmut, radd);
			}
			#endif//等价于：
			r = r * (-191841887) + 2115878600;//可以用rfuncstr获得。
			i += 8;
		}
		for (; i < jp; i++) {
			r = r * 214013L + 2531011L;
		}
		return (r >> 16) & 0x7fff;
	}
*/
//part4.
//在3号优化的经验上，可以进行最终的优化，经过这次优化，"获得任意次调用后的结果"，所需的时间变成了常数级别(对于一般的循环展开进行进一步化简)：
/*
#if 0//用这个式子打印出最后的版本：
void rfuncstr(void)
{
	long rmut = 214013L, radd = 2531011L;
	for (int i = 0; i < 32; i++)
	{
		printf("if(jp&(1<<%d)){temp=temp*(%ld)+(%ld);}\n", i,rmut,radd);
		radd = rmut * radd + radd;//r.next(a)=r*rmut(a)+radd(a),则r.next(a+a)=(r*rmut(a)+radd(a))*rmut(a)+radd(a).
		rmut *= rmut;
	}
}
#endif

int jump(unsigned jp)
{
unsigned long temp = r;
if (jp & (1 << 0)) { temp = temp * (214013) + (2531011); }
if (jp & (1 << 1)) { temp = temp * (-1443076087) + (505908858); }
if (jp & (1 << 2)) { temp = temp * (-570470319) + (159719620); }
if (jp & (1 << 3)) { temp = temp * (-191841887) + (2115878600); }
if (jp & (1 << 4)) { temp = temp * (1136269121) + (1043415696); }
if (jp & (1 << 5)) { temp = temp * (-762265983) + (-2108810976); }
if (jp & (1 << 6)) { temp = temp * (-2099004159) + (-2075229632); }
if (jp & (1 << 7)) { temp = temp * (-1085244927) + (-41532288); }
if (jp & (1 << 8)) { temp = temp * (-121310207) + (-542013184); }
if (jp & (1 << 9)) { temp = temp * (2048518145) + (-638119424); }
if (jp & (1 << 10)) { temp = temp * (376688641) + (1581130752); }
if (jp & (1 << 11)) { temp = temp * (-1243111423) + (1706838016); }
if (jp & (1 << 12)) { temp = temp * (-1882243071) + (1886949376); }
if (jp & (1 << 13)) { temp = temp * (-1348567039) + (1961959424); }
if (jp & (1 << 14)) { temp = temp * (-1623392255) + (971128832); }
if (jp & (1 << 15)) { temp = temp * (1048182785) + (-1278967808); }
if (jp & (1 << 16)) { temp = temp * (2096365569) + (1737031680); }
if (jp & (1 << 17)) { temp = temp * (-102236159) + (-820903936); }
if (jp & (1 << 18)) { temp = temp * (-204472319) + (-1641807872); }
if (jp & (1 << 19)) { temp = temp * (-408944639) + (1011351552); }
if (jp & (1 << 20)) { temp = temp * (-817889279) + (2022703104); }
if (jp & (1 << 21)) { temp = temp * (-1635778559) + (-249561088); }
if (jp & (1 << 22)) { temp = temp * (1023410177) + (-499122176); }
if (jp & (1 << 23)) { temp = temp * (2046820353) + (-998244352); }
if (jp & (1 << 24)) { temp = temp * (-201326591) + (-1996488704); }
if (jp & (1 << 25)) { temp = temp * (-402653183) + (301989888); }
if (jp & (1 << 26)) { temp = temp * (-805306367) + (603979776); }
if (jp & (1 << 27)) { temp = temp * (-1610612735) + (1207959552); }
if (jp & (1 << 28)) { temp = temp * (1073741825) + (-1879048192); }
if (jp & (1 << 29)) { temp = temp * (-2147483647) + (536870912); }
if (jp & (1 << 30)) { temp = temp * (1) + (1073741824); }
if (jp & (1 << 31)) { temp = temp * (1) + (-2147483648); }//注意值为1的参数出现了，显示了长周期计算后的规律性。
return ((r = temp) >> 16) & 0x7fff;
	}
*/
//在这个基础上可以进一步优化(再次k*k展开)，这个优化交给编译器进行。
//这个jump处理特殊的情形时，效率还会低于一开始的版本。为此，保留前者，并将这个常数级jump命名为deepjump。
//以下就是完整的代码：
struct tprand
{
	unsigned long r;
	tprand(unsigned seed=0) { r = seed; }
	int operator()(void)
	{
		return((r = r * 214013L
			+ 2531011L) >> 16) & 0x7fff;
	}
	int operator()(unsigned long r)const
	{
		return ((r * 214013L
			+ 2531011L) >> 16) & 0x7fff;
	}
	int jump(int jp)
	{
		int i = 0;
		while (i < jp - 7)
		{
			r = r * (-191841887) + 2115878600;
			i += 8;
		}
		for (; i < jp; i++) {
			r = r * 214013L + 2531011L;
		}
		return (r >> 16) & 0x7fff;
	}
	int deepjump(unsigned jp)
	{
		unsigned long temp = r;
		if (jp & (1 << 0)) { temp = temp * (214013) + (2531011); }
		if (jp & (1 << 1)) { temp = temp * (-1443076087) + (505908858); }
		if (jp & (1 << 2)) { temp = temp * (-570470319) + (159719620); }
		if (jp & (1 << 3)) { temp = temp * (-191841887) + (2115878600); }
		if (jp & (1 << 4)) { temp = temp * (1136269121) + (1043415696); }
		if (jp & (1 << 5)) { temp = temp * (-762265983) + (-2108810976); }
		if (jp & (1 << 6)) { temp = temp * (-2099004159) + (-2075229632); }
		if (jp & (1 << 7)) { temp = temp * (-1085244927) + (-41532288); }
		if (jp & (1 << 8)) { temp = temp * (-121310207) + (-542013184); }
		if (jp & (1 << 9)) { temp = temp * (2048518145) + (-638119424); }
		if (jp & (1 << 10)) { temp = temp * (376688641) + (1581130752); }
		if (jp & (1 << 11)) { temp = temp * (-1243111423) + (1706838016); }
		if (jp & (1 << 12)) { temp = temp * (-1882243071) + (1886949376); }
		if (jp & (1 << 13)) { temp = temp * (-1348567039) + (1961959424); }
		if (jp & (1 << 14)) { temp = temp * (-1623392255) + (971128832); }
		if (jp & (1 << 15)) { temp = temp * (1048182785) + (-1278967808); }
		if (jp & (1 << 16)) { temp = temp * (2096365569) + (1737031680); }
		if (jp & (1 << 17)) { temp = temp * (-102236159) + (-820903936); }
		if (jp & (1 << 18)) { temp = temp * (-204472319) + (-1641807872); }
		if (jp & (1 << 19)) { temp = temp * (-408944639) + (1011351552); }
		if (jp & (1 << 20)) { temp = temp * (-817889279) + (2022703104); }
		if (jp & (1 << 21)) { temp = temp * (-1635778559) + (-249561088); }
		if (jp & (1 << 22)) { temp = temp * (1023410177) + (-499122176); }
		if (jp & (1 << 23)) { temp = temp * (2046820353) + (-998244352); }
		if (jp & (1 << 24)) { temp = temp * (-201326591) + (-1996488704); }
		if (jp & (1 << 25)) { temp = temp * (-402653183) + (301989888); }
		if (jp & (1 << 26)) { temp = temp * (-805306367) + (603979776); }
		if (jp & (1 << 27)) { temp = temp * (-1610612735) + (1207959552); }
		if (jp & (1 << 28)) { temp = temp * (1073741825) + (-1879048192); }
		if (jp & (1 << 29)) { temp = temp * (-2147483647) + (536870912); }
		if (jp & (1 << 30)) { temp = temp * (1) + (1073741824); }
		if (jp & (1 << 31)) { temp = temp * (1) + (-2147483648); }
		return ((r = temp) >> 16) & 0x7fff;
	}
};

//测试代码如下：
int main()
{
	//srand(1001);
	tprand rnd(1001);
	//for (int i = 0,j=0; i < 64; i++,j==7?j=0,putchar('\n'):j++) {
	//	printf("%5d,%-5d\t", rand(), rnd());
	//}//tprand()得到了正确的行为。(调用k次后新的调用相等)
	//进一步测试debug和release在jump上的效率：
	clock_t from, to;
#define initrand 1001
#define testloop 1725//随便给一个值。
	//库的rand：
	srand(initrand);//初始化
	from = clock();
	for (int i = 0; i < 65536; i++)
		for (int k = 0; k < testloop; k++)
			rand();//jump testloop次。
	to = clock();
	printf("rand loop:%d-%lu\n", to - from, rand());//再次rand一次获得结果。
	//rand类：
	//普通循环：
	rnd.r = initrand;
	from = clock();
	for (int i = 0; i < 65536; i++)
		for (int k = 0; k < testloop; k++)
			rnd();
	to = clock();
	printf("plain loop:%d-%lu\n", to - from, rnd());
	//普通jump函数：
	rnd.r = initrand;
	from = clock();
	for (int i = 0; i < 65536; i++)
		rnd.jump(testloop);
	to = clock();
	printf("plain jump:%d-%lu\n", to - from, rnd());
	//deep jump：
	rnd.r = initrand;
	from = clock();
	for (int i = 0; i < 65536; i++)
		rnd.deepjump(testloop);//deepjump具有最高的效率。
	to = clock();
	printf("deep jump:%d-%lu\n", to - from, rnd());
	//以及：
	rnd.deepjump(65536 * testloop);//检验略。
	//得到的结论：tprand类的行为与rand()完全一致，且效率更优。
	//deepjump和jump得到了正确的行为。(调用k次后新的调用相等)
	//在需要长周期jump的情况下，deepjump的效率远高于其它的实现。
}
//一个输出示例：(vs release64下)
/*
rand loop:4531-12336
plain loop:87-12336
plain jump:29-12336
deep jump:0-12336
*/

有空的话，后边会更新一个利用类中的jump函数的例子。

【专家独推】全网最全Matlab常用函数（包括按首字母进行分类）
左手の明天的博客
03-30 3万+
目录 1、求组合数 2、求阶乘 3、求全排列 4、求指数 5、求行列式 6、求矩阵的转置 7、求向量的指数 8、求自然对数 9、求矩阵的逆矩阵 10、多项式的乘法运算 11、多项式除法 12、求一个向量的最大值 13、求矩阵的最大值和最小值 14、求和与求积 15、平均值、标准方差 16、相关系数 17、排序 18、多项式的求导 19、多项式的求值 20、常用的基本数学函数 21、常用的三角函数 22、适用于向量的常用函数 23、MATLAB的永久常数 24、
全局型拓扑相变算法：将整个图形结构按照目标函数进行优化
AI天才研究院
10-09 735
拓扑相变（Topology Variation）问题是指在网络中任意两点之间都存在一条路径（路径可以经过多条边），而该路径的数目可能随时间变化。拓扑相变问题的重要性不亚于任何一道数学分析题目的重要性，其应用场景也远不止于科技领域。比如，在电力系统中，要计算某一时刻网络整体的总能耗，就需要考虑不同路径的能耗差异。再如，在车流网路中，还可以考虑多条路径上车辆通行的流量差异，以便选择一条能够最大化车流量的路径。当然，拓扑相变问题同样具有广泛的经济、社会和工程应用。
rand函数实现方法
04-14
同过调用时间函数 自己写的rand()函数 可以取代库函数rand() 方便掌握 易于理解
C语言实现RAND函数的方法
slc1112的博客
12-12 2310
C语言使用rand()%一个值就可以实现生成一个伪随机数供我们使用，那么rand函数是如何实现的呢？我们自己可不可以编辑出来？其实是可以的，rand作为伪随机数发生器产生的是一个伪随机数，一般的用途能够满足。 要想实现这个函数，需要用一个公式，x=ax+b%65536用这样的公式就可以简单的实现随机数了，至于为什么是214013、2531011这两个数应该是有个内部逻辑，数学上的验证而来，这两个数如果任意取可能效果不是很好。 static long holdrand = 1L; void __cdecl s
C语言——rand函数
Stewie Lee的博客
05-04 9637
这是一个在 C 标准库中定义的函数，用于生成伪随机数，默认情况下，它生成从 0 到RAND_MAX的伪随机数，其中RAND_MAX是一个常数，通常是32767。返回产生的从 0 到RAND_MAX的伪随机数。在使用 rand 函数时要配合 srand 函数设置 rand 函数的随机种子。
rand函数的实现原理
热门推荐
Cashey1991的专栏
04-14 2万+
rand函数的实现原理rand函数产生的是伪随机数，也就是说它不是一个真实的随机数。那么伪随机数是怎么实现的呢？原理大概如下：如果约定：a1=f(seed),an+1=f(an)a_1 = f(seed), a_{n+1} = f(a_n)那你可以行到一个序列：a1,a2,a3...ana_1, a_2, a_3 ... a_n，那么要制作一个伪随机函数rand，只需要让它每调用一次就返回序列的下
详解PHP中array_rand函数的使用方法
10-21
虽然这同样能实现随机取值，但`array_rand`在实现上可能更为优化，使得其在多数场景下成为首选。 此外，文章提供了一个实例，展示了如何利用`array_rand`创建随机密码。这个`make_password`函数接收一个可选的参数`...
【C语言】利用rand函数不重复地生成不重复的数组发牌且配对！扑克牌管理操作系统的升级与优化（CodeBlocks）
rain_HYS的博客
04-18 2032
一个比简单略难的扑克牌管理操作系统——2.0 运用随机数和结构体完成程序的设计与开发
如何使用MATLAB实现模拟退火算法来优化多峰值函数？请提供具体的代码实现步骤和解释。
最新发布
10-26
通过上述步骤，我们利用MATLAB实现了一个基本的模拟退火算法，并用它来优化了Rastrigin多峰值函数。模拟退火算法的全局搜索能力使其在面对多峰值问题时表现出色。实现过程中，关键点在于如何设计产生候选解的扰动...
rand函数的使用及实现原理
实践之路
10-02 5136
最近很想知道c语言中random是怎么实现的，查了一些资料，总结了一下： 参考：http://topic.csdn.net/u/20091124/14/2598eca6-b66a-47d6-9603-61f669fe0334.html http://jonny131.iteye.com/blog/188829以及维基百科 ===============================
C语言之中rand()函数是如何实现的
Bamboo
03-03 2204
需要注意的是，rand()函数是一个伪随机数生成函数，它生成的随机数并非真正的随机数，而是在数学上看起来是随机的数列。由于随机数生成器的初始种子相同，因此每次程序运行时生成的随机数序列都是相同的。rand()函数是一个C标准库中的随机数生成函数，用于生成一个范围在0到RAND_MAX之间的伪随机数。其中，X(n)是上一个生成的随机数，a、c、m是一组固定的参数。生成的随机数通常是一个大整数，需要对RAND_MAX取模，得到一个范围在0到RAND_MAX之间的随机数。
C/C++中rand函数的实现
GAUSS_CLB
06-21 3542
C/C++中用了最简单的线性同余来实现伪随机数的，具体原理看这里具体的参数a,c,m参考这里#include&lt;bits/stdc++.h&gt; #include&lt;ctime&gt; #include&lt;cstdlib&gt; using namespace std; unsigned int status=0; int my_srand(unsigned int seed){ ...
rand()函数
大舟舟的博客
10-29 2195
大家再写程序的时候，有时会需要程序能产生一个随机数。那么rand()函数和srand()函数的组合使用，可以满足大家的需求。 注：建议先弄明白如何使用，然后再根据使用方法来理解。 一下是目录，大家自行跳转： 一、rand()函数和srand()函数的实现原理 二、rand()函数和srand()函数的使用方法 一、rand()函数和srand()函数的实现原理 1.1 源代码 使用这两个函数是需要添加<stdlib.h>的头文件，那么在该头文件内部该函数是什么...
rand()函数详解
静陌慕春
07-24 2万+
在编程中有时需要产生一个随机数，来满足程序所要实现的功能，这里介绍一个函数–rand()函数来实现一个随机数的产生。 使用rand()函数需要引#include<stdlib.h>头文件； rand()函数的定义：int rand(void) rand()函数的说明： 1.   rand()函数其实不是真正意义上的随机数生成器，rand()函数在使用的时候还需调用srand()函数，sra
linux rand()函数,C語言 rand函数 进阶探讨与实现
weixin_39884144的博客
05-03 1061
C语言中随机函数应用可能大家都知道C语言中的随机函数random，可是random函数并不是ANSI C标准，所以说，random函数不能在gcc,vc等编译器下编译通过。那么怎么实现C语言中的随机函数呢？除了random函数，还有一个rand函数，也是一个随机函数，可以产生从0到rand_max的随机数。#include #include int main(){int x;x = rand();...
猜数字游戏C语言代码实现
2302_78391795的博客
12-01 864
游戏可以连续进行，每次游戏有五次猜测机会。描述——随机产生一个100到200的整数，猜测产生的数字。二、game（）函数实现产生随机数并猜数字的过程。三、menu（）函数封装游戏菜单。一、主函数 实现循环游戏的主体。代码和运行截图在下方。
c语言用rand() 函数，实现random(int m)
SapphireStart
09-30 1万+
函数rand()是真正的随机数生成器，而srand()会设置供rand()使用的随机数种子。如果你在第一次调用rand()之前没有调用srand()，那么系统会为你自动调用srand()。而使用同种子相同的数调用 rand()会导致相同的随机数序列被生成。
183-用rand(N)实现rand(M)
LINZEYU666的博客
02-10 984
1、用rand(7)实现rand(5) rand5可以随机生成1,2,3,4,5；rand7可以随机生成1,2,3,4,5,6,7。 一个非常直观的想法就是不断地调用rand7，直到它产生1到5之间的数，然后返回。 代码如下： int Rand5() { int x = ~(1<<31); // max int while(x > 5) x = Rand7(); return x; } 这个函数可以等概率地产生1到5的数吗？ 首先，它确确实实只会返
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值