快速生成随机出现的随机数-Fastgenerationofrandomnumbersthatappearrandom

A linear feedback shift register probably does what you want.

线性反馈移位寄存器可能会做你想要的。

Edit in light of an updated question: You should look at a shuffle bag, although I'm not sure how fast this could run. See also this question.

根据更新的问题进行编辑:你应该看一个洗牌包,虽然我不确定它能跑得多快。另见这个问题。

I don't really know what you mean by bit patterns that "look" random. Is there some algorithm for defining what that is? One way might be to formulate an array consisting of only those numbers which are random enough for your purpose, then, randomly select elements from that array and push them onto the stream. The thing you seem to be trying to do seems bizarre to me and may be doomed to failure though. What happens if you have two 32 bit numbers which taken individually would meet your criteria for apparent randomicity, but when placed side by side make a sufficiently long stream of 0's or 1's to look made up?

我真的不知道“看起来”随机的位模式是什么意思。是否有一些算法来定义它是什么?一种方法可能是制定一个数组,该数组只包含那些随机足以满足您的目的的数字,然后从该数组中随机选择元素并将它们推送到流中。你似乎想要做的事情对我来说似乎很奇怪,但可能注定要失败。如果您有两个单独的32位数字符合您的表观随机性标准会发生什么,但是当并排放置时,会产生一个足够长的0或1的流来组成?

Finally, I couldn't resist this.

最后,我无法抗拒这一点。

You need to decide by exactly what rules you decide if something "looks random". Then you take a random number generator that produces enough "real randomness" for your purpose, and every time it generates a number that doesn't look random enough, you throw that number away and generate a new one.

如果“看起来像是随机的”,你需要确定你决定的规则。然后你拿一个随机数生成器,为你的目的产生足够的“真实随机性”,每当它生成一个看起来不够随机的数字时,你抛出那个数字并生成一个新的数字。

Or you directly produce a sequence of "random" bits and every time the random generator outputs the "wrong" next bit (that would make it look not-random), you just flip that bit.

或者你直接产生一系列“随机”位,每次随机发生器输出“错误”的下一位(这会使它看起来不是随机的),你只需翻转那一位。

Here's what I'd do. I'd use a number like 00101011100101100110100101100101 and rotate it by some random amount each time.

这就是我要做的。我会使用像00101011100101100110100101100101这样的数字并每次随机旋转它。

But are you sure that a typical pseudo random generator wouldn't do? Have you tried it? You con't very many long strings of 0s and 1s anyhow.

但你确定一个典型的伪随机发生器不会这样做吗?你试过吗?无论如何,你不会有很多长串的0和1。

If you're going to use a library random number and you're worried about too many or too few bits being set, there are cheap ways of counting bits.

如果您要使用库随机数并且您担心设置的位太多或太少,则可以通过便宜的方式对位进行计数。

Random numbers often have long sequences of 1s and 0s, so I'm not sure I fully understand why you can't use a simple linear congruential generator and shift in or out how ever many bits you need. They're blazing fast, look extremely random to the naked eye, and you can choose coefficients that will yield random integers in whatever positive range you need. If you need 32 "random looking" bits, just generate four random numbers and take the low 8 bits from each.

随机数通常有1和0的长序列,所以我不确定我完全理解为什么你不能使用简单的线性同余生成器并移入或移出你需要的多少位。它们非常快速,肉眼看起来非常随机,你可以选择在你需要的任何正范围内产生随机整数的系数。如果你需要32个“随机查找”位,只需生成四个随机数并从每个位取低8位。

You don't really need to implement your own at all though, since in most languages the random library already implements one.

你根本不需要实现自己的,因为在大多数语言中,随机库已经实现了一个。

If you're determined that you want a particular density of 1s, though, you could always start with a number that has the required number of 1s set

但是,如果您确定要特定密度为1,则始终可以从具有所需数量1的数字开始

int a = 0x00FF;

then use a bit twiddling hack to implement a bit-level shuffle of the bits in that number.

然后使用一些麻烦的黑客实现该数字位的位级混乱。

If you are looking to avoid long runs, how about something simple like:

如果你想避免长跑,那么简单的事情如下:

#include 

class generator {
public:
   generator() : last_num(0), run_count(1) { }

   bool next_bit() {
      const bool flip = rand() > RAND_MAX / pow( 2, run_count);
                               // RAND_MAX >> run_count ? 
      if(flip) {
         run_count = 1;
         last_num = !last_num;
      } else
         ++run_count;

      return last_num;
   }
private:
   bool last_num;
   int run_count;
};

Runs become less likely the longer they go on. You could also do RAND_MAX / 1+run_count if you wanted longer runs

运行的时间越长,运行的可能性就越小。如果你想要更长的跑步,你也可以做RAND_MAX / 1 + run_count

Since you care most about run length, you could generate random run lengths instead of random bits, so as to give them the exact distribution you want.

由于您最关心的是运行长度,因此您可以生成随机运行长度而不是随机位,以便为它们提供所需的精确分布。

The mean run length in random binary data is of course 4 (sum of n/(2^(n-1))), and the mode average 1. Here are some random bits (I swear this is a single run, I didn't pick a value to make my point):

随机二进制数据的平均运行长度当然是4(n /(2 ^(n-1))之和)和模式平均值1.这里有一些随机位(我发誓这是一次运行,我没有选择一个值来表明我的观点):

0111111011111110110001000101111001100000000111001010101101001000

See there's a run length of 8 in there. This is not especially surprising, since run length 8 should occur roughly every 256 bits and I've generated 64 bits.

看那里的跑步长度为8。这并不特别令人惊讶,因为运行长度8应该大约每256位发生一次,并且我生成了64位。

If this doesn't "look random" to you because of excessive run lengths, then generate run lengths with whatever distribution you want. In pseudocode:

如果由于运行长度过长而不“随机”,则生成所需分布的运行长度。在伪代码中:

loop
    get a random number
    output that many 1 bits
    get a random number
    output that many 0 bits
endloop

You'd probably want to discard some initial data from the stream, or randomise the first bit, to avoid the problem that as it stands, the first bit is always 1. The probability of the Nth bit being 1 depends on how you "get a random number", but for anything that achieves "shortish but not too short" run lengths it will soon be as close to 50% as makes no difference.

您可能想要从流中丢弃一些初始数据,或者将第一位随机化,以避免出现问题,第一位始终为1.第N位为1的概率取决于您“获得”的方式一个随机数字“,但对于任何达到”短暂但不太短“的运行长度,它将很快接近50%,因为没有区别。

For instance "get a random number" might do this:

例如,“获取随机数”可能会这样做:

get a uniformly-distributed random number n from 1 to 81
if n is between 1 and 54, return 1
if n is between 55 and 72, return 2
if n is between 72 and 78, return 3
if n is between 79 and 80, return 4
return 5

The idea is that the probability of a run of length N is one third the probability of a run of length N-1, instead of one half. This will give much shorter average run lengths, and a longest run of 5, and would therefore "look more random" to you. Of course it would not "look random" to anyone used to dealing with sequences of coin tosses, because they'd think the runs were too short. You'd also be able to tell very easily with statistical tests that the value of digit N is correlated with the value of digit N-1.

这个想法是长度N的运行概率是长度N-1运行概率的三分之一,而不是一半。这将使平均运行时间缩短得多,并且最长运行时间为5,因此对您来说“看起来更随机”。当然,任何习惯于处理硬币投掷序列的人都不会“看起来随意”,因为他们认为跑步太短了。您还可以通过统计测试很容易地判断出数字N的值与数字N-1的值相关。

This code uses at least log(81) = 6.34 "random bits" to generate on average 1.44 bits of output, so is slower than just generating uniformly-distributed bits. But it shouldn't be much more than about 7/1.44 = 5 times slower, and a LFSR is pretty fast to start with.

此代码至少使用log(81)= 6.34“随机位”来生成平均1.44位的输出,因此比生成均匀分布的位慢。但它应该不会超过7 / 1.44 = 5倍慢,而LFSR开始时速度相当快。

This is how I would examine the number:

这是我如何检查数字:

const int max_repeated_bits = 4;  /* or any other number that you prefer */

int examine_1(unsigned int x) {      
  for (int i=0; i