【问题标题】:"Randomness Length" of srand in C?C中srand的“随机长度”?
【发布时间】:2016-08-18 15:33:23
【问题描述】:

所以,我必须生成一个长度为 N 的 int 向量,其中只有 n 个随机元素为 1,其他元素为 0。 为了做到这一点,我创建了一个长度为 N 的向量,对其进行初始化,使前 n 个元素为 1,其他元素为 0,然后开始使用一个简单的函数对其进行洗牌,该函数接受一个 int 向量,生成随机数从 0 到 N 并在 rand 的输出之后重新洗牌。 我的问题是:我可以“信任”多少次随机生成器给我不同的数字序列,以便我每次都能得到不同的向量? 如果我运行这个函数,比如说,100 万次,我是否获得了 100 万种不同的组合(假设有超过 1m 种不同的方式来重新排序我的向量)? 如果没有,我应该如何进行?有办法检查我是否正在生成以前生成的序列?

编辑: 关于算法可能存在的缺陷,这里是(我在主函数中只做一次 srand(time(NULL)) ,然后再调用这个):

 void Shuffle(int vector[],int n, int N)
 {
  int i = 0;
  int j = 0;
  for(i=0;i<n;i++)
     {
      j = rand() % N;
      if(j!=i)
         swap(&vector[i],&vector[j]);
     }
  }

swap 是一个交换向量元素的函数。我不明白为什么应该有缺陷。我是否比其他人更有可能得到一些结果?我知道 Fisher-Yates Shuffle 算法,我写这个是为了节省一些时间 执行...

【问题讨论】:

  • 听起来你的随机播放有错误。 en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle 尤其是en.wikipedia.org/wiki/…
  • 如果您使用 rand 通过调用它 N 次并使用这些随机值作为输出顺序的索引来生成排列,是的,这是一个错误。目前还不清楚您所说的“改组”到底是什么意思。
  • 我的函数是这样做的:它是前 n 个元素的 for,每个元素生成一个从 0 到 N-1 的随机数,如果该数字与元素的位置不同,则切换两个位置。对吗?
  • 这不仅仅是因为您的 RNG 的总序列长度。完全有可能有重复的子序列,即使总序列长度比您需要的长得多。

标签: c vector random srand


【解决方案1】:
  1. 正如评论中提到的,随机播放算法存在缺陷。您应该使用Fisher-Yates 随机播放。算法有偏差的证明相对简单:考虑 1 和 0 的序列未被算法改变的概率。如果选择的每个n 随机数都小于n,就会发生这种情况,概率为 (n/N)n 或 nn/ Nn。正确的概率是 1/(N 选择 n),即 n!/(N×(N-1)×…(N-n+1))。如果n 相对于N 较小,则后一个表达式非常接近n!/Nn。由于 nn 比 n! 大得多,因此算法产生未改变序列的概率比它应该的要大得多。 (在原始点中包含大多数但不是全部 1 的序列也被过度生产,但没有那么戏剧性。)

  2. 在任何程序中,您都不应多次调用srand(除非您真的知道自己在做什么)。 srand种子随机数生成器;播种后,每次需要新号码时,您只需拨打rand。 (这一点是由问题的标题引起的,错误地使用srand这一事实似乎很常见。)

  3. 标准 C 库 rand 函数不提供任何质量保证,并且一些实现具有令人痛苦的小范围和短周期。但它们可能足以进行一百万次随机洗牌。

  4. 即使您的随机数生成器每次都产生不同的序列,并且即使您修复了 shuffle 函数以进行适当的 Knuth-Yates shuffle,您仍然会得到重复,因为您正在洗牌的向量具有重复的值。因此,两个不同的 shuffle 可以产生相同的序列。考虑 n 为 2 的简单情况,因此您的初始向量是两个 1,后跟 N-2 个 0。这两个 1 彼此无法区分,因此如果您的第一步交换到位置 k 而您的第二步交换到位置 l,这将产生与先交换到 l 然后到 k 完全相同的结果.


我认为你真正想要做的是从 N 对象中构造一个随机的 combination of n。有N choose n这样的可能组合;理想情况下,每个这样的组合都应该以相等的概率生成。

以下是一些实现此目的的算法。它们都是 O(N) 时间,因为不可能在小于线性的时间内填充长度为 N 的布尔向量。但是,如果您只能使用 1 的索引列表,那么第二种算法是 O(n),或者如果您需要对索引进行排序,则为 O(n log n)。可以在this answer 中引用的论文中找到真正的 O(n) 算法,它可以按排序顺序生成索引,如果N 非常大而n 相当小,这可能是合适的。

以下函数被几种算法使用。正如它的评论所表明的,它可以改进,但它会与一个好的 RNG 一起工作。 rand() 不是一个好的 RNG。

/* This is not a good implementation of rand_range
 * because some rand() implementations exhibit poor randomness
 * of low-order bits. (And also the bias issue if RAND_MAX is
 * small.) Better random number generators exist :) */
/* Produces a random integer in the half-open range [lo, hi) */
int rand_range(int lo, int hi) {
  return lo + rand() % (hi - lo);
}

1。水库取样

适用于大样本量的简单算法是reservoir sampling:

/* vec must be a vector of size at least N. Randomly
 * fills the vector with n 1s and N-n 0s.
 */ 
void random_fill(int vec[], int N, int n) {
  int i;
  for (i = 0; n; ++i) {
    if (rand_range(0, N-i) < n) {
      vec[i] = 1;
      --n;
    }
    else
      vec[i] = 0;
  }
  for (; i < N; ++i) vec[i] = 0;
}

2。洗牌指数

另一种可能性是通过对索引列表进行前缀洗牌来生成 1 的索引:

int random_fill(int vec[], int N, int n) {
  /* For simplicity, use a temporary vector */
  int* inds = malloc(N * sizeof *inds);
  for (int i = 0; i < N; ++i) inds[i] = i;
  for (int i = 0; i < n; ++i) {
    int j = rand_range(i, N);
    int t = inds[j]; inds[j] = inds[i]; inds[i] = t;
  }
  for (int i = 0; i < N; ++i) vec[i] = 0;
  for (int i = 0; i < n; ++i) vec[inds[i]] = 1;
  free(inds);
}

3。从枚举序列中选择

如果N choose n 不是太大(也就是说,您可以在没有整数溢出的情况下计算它),生成随机序列的一种方法是选择一个小于N choose n 的随机整数,然后生成与该序数的组合使用一些可能的序列枚举。 (如果您使用rand(),您应该知道即使N choose n 可以计算而不会溢出,它可能仍然大于RAND_MAX,在这种情况下rand() 不会生成所有可能的序数。 )

上面的水库采样算法可以直接适应产生一个枚举:

/* Fills vec with the kth sequence of n 1s and N-n 0s, using
 * an unspecified ordinal sequence; every value of k between 0
 * and (N choose n) - 1 produces a distinct sequence.
 */
void ordinal_fill(int vec[], int N, int n, int k) {
  for (int i = 0; N; ++i, --N) {
    int r = (k * n) % N;
    if (r < n) {
      vec[i] = 1;
      k = (k * n) / N;
      --n;
    } else {
      vec[i] = 0;
      k = (k * (N - n)) / N;
    }
  }
}

(live on ideone)

上面的程序没有对其他的序数值做任何假设 而不是它是正数并且适合整数。实际上,它将采取 模N choose n,尽管该值从未明确计算过。如果你 使用 uint64_t 而不是 int 和一个随机数生成器,它可以 产生大范围的随机数,你可以通过给函数提供一个随机数来生成随机序列。当然,这并不能保证序列是唯一的。

本质上,该函数通过使用序数值 (k) 作为水库采样算法所需的“随机”数的来源来工作。每个序数(mod N choose n)对应一个不同的序列(证明留作练习)。因为序数空间是按模而不是按量来划分的,所以序数序列作为一个序列可能不是特别有用,但可以保证它是一个完整的序列。

按大小划分(使用组合编号之类的东西 system) 可能更快——例如,它不需要除法——但它需要有效地访问二项式数字,而上述函数不需要。如果每一步都计算二项式系数,则需要进行除法,从而消除了很多速度优势。

【讨论】:

  • 这是一个很好的实现,但让我困扰的是,当我运行它时可能需要很长时间。我的意思是可能需要 (N-n)n 步(如果我没记错的话)给我向量。我使用的算法只需 n 步即可完成。
  • @FrancescoDiLauro:是的,但是这个是公正的。一个非常简单的测试将显示您算法中的偏差。存在更快的算法,但它们依赖于过于复杂的数值分析。
  • @FrancescoDiLauro:添加了对提供更快算法的论文的间接引用。这是算法中偏差的简单证明:“洗牌”导致原始向量的概率为 (n/N)^n。但它应该是 1/(N 选择 n)。说n是2;第一个表达式是 4/N^2,第二个表达式是 2/(N(N-1)),或大约 2/N^2,因此原始向量的可能性大约是应有的两倍。
  • 第二个想法我同意,但让我失望的是lo, hi 的名字。名字听起来应该是[lo, hi],两端都包括在内。也许一个不同于hi 的名字? (您添加的评论可以 - UV)
  • @FrancescoDiLauro:好的,添加了另一个算法。我不认为它实际上会在实践中更快。
【解决方案2】:

为所有可能的序列编号(阅读enumeration part of the Wikipedia article about combinations),然后依次选择每个序列(可选在随机化之后)。

#1   - 1 1 1 1 1 1 1 1 0 0 0
#2   - 1 1 1 1 1 1 1 0 1 0 0
#3   - 1 1 1 1 1 1 1 0 0 1 0
#4   - 1 1 1 1 1 1 1 0 0 0 1
#4   - 1 1 1 1 1 1 0 1 1 0 0
...
#165 - 0 0 0 1 1 1 1 1 1 1 1

【讨论】:

  • +1,但我不得不承认,你如何以编程方式从序数到特定序列对我来说并不明显......
  • @OliverCharlesworth 你的意思是如何有效地迭代保留 n 位数字?
  • @2501:我的意思是给定例如4,如何在不遍历所有先前序列的情况下到达 1 1 1 1 1 1 1 0 0 0 1(在上面的示例中)?
  • @2501:您使用该维基百科页面中提到的组合数字系统来分解序数。或者您可以使用水库采样算法,使用序数生成连续的随机数。
  • @rici 当然采样真的很简单,应该可以。在这里,让我推你超过 100k :-)
【解决方案3】:

您可以计算您的序列的 CRC,这将对订单敏感。找到 CRC32 的公共域实现并保存每个序列的 32 位值。如果 CRC 不同,则顺序不同。如果 CRC 相同,则它们可能相同(有 1/4 亿的机会它们将具有相同的 CRC,但序列不同)。

【讨论】:

  • 序列的CRC是否依赖于运行代码的机器?
  • 不应该,只要你同意正确的系数。有关所有流行系数的详细列表,请参阅关于 CRC 的 Wikipedia 文章。
【解决方案4】:

很多 PRNG 的周期长度是已知的,例如参见 Amy Glen 的论文“On the Period Length of Pseudorandom Number Sequences” [2002]。您的 LibC 的实际 rand() 实现的时期是未知的,您需要在源中查找它(例如:glibc-2.22/stdlib/rand_r.c)并自己计算它(如何在上面的论文中)或文档(不太可能)。

请注意,您需要一段 x * N 和 x 新洗牌向量的数量和 N 该向量的长度,而且显然,两次洗牌导致相同结果的机会与N的大小成反比,即N越小,得到两个相等向量的机会就越高。

如果您想将这种风险降至最低,您需要具有良好且有保证的雪崩性能的东西,例如加密校验和。它们的计算成本很高,但您可以直接使用总和(您说您只需要零和一)并在必要时连接起来。非常小的“N”问题不会消失,而是会被最小化。

这也取决于你打算做什么,你需要它做什么。有时,尤其是使用 Monte Carlo 方法,一种 PRNG 似乎比另一种获得更好的结果。

[2002] 格伦,艾米。 “关于伪随机数序列的周期长度。”澳大利亚阿德莱德大学(2002 年)。可在thesis.pdf获取(2016.08.18下载)

【讨论】:

    【解决方案5】:

    如果我运行这个函数,比如说,100 万次,我会得到 100 万个不同的组合吗(?)

    OP 有代码

    srand(time(NULL)); // only once in my main function
    

    time() 通常返回一个整数秒数。然后对程序的任何调用(在同一秒内)都会产生相同的结果,因此测试可能需要等待大约 12 天才能测试 100 万个组合。

    即使使用另一个源来调用srand(unsigned seed),seed 也只接受[0...UINT_MAX] 的值,可能小到 65,636 个不同的值。 (通常unsigned 有 4,294,967,296 个不同的值)。

    验证unsigned 的范围并考虑“随机”初始化的其他来源,例如进程ID 或dev/random

    【讨论】:

    • 所以我假设我“保证”了 65,635 个不同的随机数。我错了吗?
    • @Francesco Di Lauro(65,536 对 65,535)。尽管规范不保证,但可以合理假设。 srand()/rand()的细节和质量不具体。
    • @FrancescoDiLauro:RAND_MAX 可能小到 37267,所以你真的只能保证 32768 个不同的值。根据 RNG,即使单个值重复,也可能会有(多)更长的周期。或者可能没有;标准是宽松的。如果对您很重要,请考虑使用更好的 RNG。
    • @rici 和 OP 详细信息:这里回答/评论的 65,536 或更多是关于随机数生成序列代码中将经历的不同起点的数量。这不同于从rand() 返回的值范围,即[0...RAND_MAX] 和RAND_MAX &lt;= INT_MAX &lt;= UINT_MAX。此外,正如 rici 所评论的那样,cycle 在 pattern 重复之前可能会远更长。
    • @chux:另一个细节:7.22.2.1/5:“RAND_MAX 宏的值应至少为 32767。”因为rand 返回一个正数int,32767 &lt;= RAND_MAX &lt;= INT_MAX。 srand 确实接受 unsigned 但这对 RAND_MAX 没有影响。
    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2013-03-05
    • 1970-01-01
    • 1970-01-01
    • 2012-05-16
    • 2011-06-11
    • 1970-01-01
    相关资源
    最近更新 更多