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

最新推荐文章于 2023-03-03 11:36:13 发布
最新推荐文章于 2023-03-03 11:36:13 发布
阅读量238 收藏
点赞数
分类专栏： 杂项 文章标签： 算法 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函数的例子。

「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MySQL rand函数实现随机数的方法
12-16
顺便给你找了点关于mysql rand函数的实例，如下：那就在insert 命令中，value()里面用rand()，注意字段宽度是否够一直以为mysql随机查询几条数据，就用SELECT * FROM `table` ORDER BY RAND() LIMIT 5 就可以了。
数字序列的最大间隔（harsh）
weixin_52117036的博客
10-27 1053
/*题目描述 题目描述 请输出数字序列的最大间隔。 请使用以下伪随机数生成函数 rand32 () 生成伪随机数 int seed ; int rand(){ return((( seed = seed * 214013L + 2531011L) >> 16) & 0x7fff); } int rand32(){ return ((rand() << 16) + (rand() << 1) + rand() % 2); } Input Format
C语言rand()函数产生随机数详解
热门推荐
weixin_44049823的博客
09-28 3万+
在调用rand函数之前，会先查询是否主动调用过srand(seed)来为伪随机数生成器设定种子，如果有，那么就按照我们的代码设定种子，即初始化seed的起始值，若没有调用srand(seed)，那么系统会自动给seed赋初始值，即自动调用srand(1)一次，也就是将seed的值设置为1。如果每次调用rand函数时，种子相同，那么根据公式产生的伪随机数将是相同的。
C语言之中rand()函数是如何实现的
Bamboo
03-03 1900
需要注意的是，rand()函数是一个伪随机数生成函数，它生成的随机数并非真正的随机数，而是在数学上看起来是随机的数列。由于随机数生成器的初始种子相同，因此每次程序运行时生成的随机数序列都是相同的。rand()函数是一个C标准库中的随机数生成函数，用于生成一个范围在0到RAND_MAX之间的伪随机数。其中，X(n)是上一个生成的随机数，a、c、m是一组固定的参数。生成的随机数通常是一个大整数，需要对RAND_MAX取模，得到一个范围在0到RAND_MAX之间的随机数。
求整数最大间隔-性能（hash算法）
weixin_54520840的博客
10-28 690
题目描述 请输出数字序列的最大间隔。 请使用以下伪随机数生成函数 rand32 () 生成伪随机数 int seed ; int rand(){ return((( seed = seed * 214013L + 2531011L) >> 16) & 0x7fff); } int rand32(){undefined return ((rand() << 16) + (rand() << 1) + rand() % 2); }Input Format 2个整数，n
C语言实现RAND函数的方法
slc1112的博客
12-12 2219
C语言使用rand()%一个值就可以实现生成一个伪随机数供我们使用，那么rand函数是如何实现的呢？我们自己可不可以编辑出来？其实是可以的，rand作为伪随机数发生器产生的是一个伪随机数，一般的用途能够满足。 要想实现这个函数，需要用一个公式，x=ax+b%65536用这样的公式就可以简单的实现随机数了，至于为什么是214013、2531011这两个数应该是有个内部逻辑，数学上的验证而来，这两个数如果任意取可能效果不是很好。 static long holdrand = 1L; void __cdecl s
详解C语言中rand函数的使用
01-20
我们使用C语言的rand函数，生成的也是伪随机数。 c语言之rand函数的使用 1、写入头文件 #include <stdlib> #include <stdio> #include 2、变量的定义 void main( void ) { int i,k; 3、srand( (unsigned)time( ...
生成随机数rand函数的用法详解
01-01
函数rand()是真正的随机数生成器，而srand()会设置供rand()使用的随机数种子。如果你在第一次调用rand()之前没有调用srand()，那么系统会为你自动调用srand()。而使用同种子相同的数调用 srand()会导致相同的随机数...
VC随机函数srand和rand用法
01-20
前言：编程中经常需要用到随机数，当然程序（函数）本身无法生成所谓的真实的...VC中随机函数最常用就是srand和rand（实际上是属于标准C函数），其中srand负责设置随机种子，rand则负责生成随机数。使用此二随机函数需
memtester --转载
jiangchao3392的专栏
12-01 2288
转自：https://blog.csdn.net/younger_china/article/details/9534227 前言 为一究memtester原理，现对其每个函数均按照如下格式进行描述： 方法 原理 时间花销 以下是对每个测试项的简要描述： memtester-4.3.0 memtester-ARM int test_stuck_address(bufa, count); （√ ） 先全部把地址值交替取反放入对应存储位置，然后再读出比较，重复2次（官网的重复了.
rand函数实现方法
04-14
同过调用时间函数 自己写的rand()函数 可以取代库函数rand() 方便掌握 易于理解
rand()函数详解
静陌慕春
07-24 2万+
在编程中有时需要产生一个随机数，来满足程序所要实现的功能，这里介绍一个函数–rand()函数来实现一个随机数的产生。 使用rand()函数需要引#include<stdlib.h>头文件； rand()函数的定义：int rand(void) rand()函数的说明： 1.   rand()函数其实不是真正意义上的随机数生成器，rand()函数在使用的时候还需调用srand()函数，sra
C/C++中rand函数的实现
GAUSS_CLB
06-21 3446
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函数的实现原理
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，只需要让它每调用一次就返回序列的下
rand()函数
大舟舟的博客
10-29 1963
大家再写程序的时候，有时会需要程序能产生一个随机数。那么rand()函数和srand()函数的组合使用，可以满足大家的需求。 注：建议先弄明白如何使用，然后再根据使用方法来理解。 一下是目录，大家自行跳转： 一、rand()函数和srand()函数的实现原理 二、rand()函数和srand()函数的使用方法 一、rand()函数和srand()函数的实现原理 1.1 源代码 使用这两个函数是需要添加<stdlib.h>的头文件，那么在该头文件内部该函数是什么...
memtester4.3.0
茫茫大士的专栏
12-05 948
为一究memtester原理，现对其每个函数均按照如下格式进行描述：以下是对每个测试项的简要描述：方法test_stuck_address函数名： 基本pattern按照下图所示，j=0时，先把P1的地址值写入对应的内存位置处，然后P2取反放入对应位置处，如此反复；然后下一轮开始，即j=1，把上述步骤反过来再进行一遍即可；正在上传…重新上传取消直到16轮结束，假若发生异常就把异常的地址直接返回即可！目的（原理）为了验证是否有地址无法访问，验证的是地址线。时间花销条件： 全空间1G Byte ，DDR带宽16
C库：rand和srand的实现原理以及C库中源代码
桔子
05-04 1万+
一、rand和srand的使用示例 博主前言：对rand和srand函数使用熟练的人，这步可直接跳过不看。 1.代码示例1和运行结果 //只有rand，没有srand生成随机种子 #include&lt;stdio.h&gt; #include&lt;unistd.h&gt; void test() { int i=0; for(;i&lt;10;i++) ...
rand函数的使用及实现原理
实践之路
10-02 5002
最近很想知道c语言中random是怎么实现的，查了一些资料，总结了一下： 参考：http://topic.csdn.net/u/20091124/14/2598eca6-b66a-47d6-9603-61f669fe0334.html http://jonny131.iteye.com/blog/188829以及维基百科 ===============================
利用强化学习方法优化控制增益变量实现三辆车编队系统，给出仿真代码
最新发布
06-03
好的，你的问题是关于利用强化学习方法优化控制增益变量实现三辆车编队系统的仿真代码的。以下是一个简单的示例代码，供你参考： ```python import numpy as np import tensorflow as tf import gym # 定义车辆...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值