从范围生成随机整数

我需要一个函数，该函数将在给定范围内（包括边界值）生成一个随机整数。我没有不合理的质量/随机性要求，我有四个要求：

• 我需要它快。我的项目需要生成数百万（有时甚至数千万）的随机数，而我目前的生成器功能已被证明是瓶颈。
• 我需要它合理地统一（使用rand（）完全可以）。
• 最小-最大范围可以是<0，1>到<-32727，32727>的任何值。
• 它必须是可播种的。

我目前有以下C ++代码：

output = min + (rand() * (int)(max - min) / RAND_MAX)

问题是，它不是真正统一的-仅当rand（）= RAND_MAX时才返回max（对于Visual C ++，它是1/32727）。对于像<-1，1>这样的小范围，这是一个主要问题，在该范围中几乎永远不会返回最后一个值。

所以我拿起笔和纸，想出了以下公式（该公式基于（int）（n + 0.5）整数舍入技巧）：

但是它仍然不能给我均匀的分布。重复运行10000个样本后，值-1、0的比例为37：50：13.1。

你能建议更好的配方吗？（甚至整个伪随机数生成器函数）

一种快速的解决方案，比您的解决方案要好一些，但是仍然不能提供统一的分布式解决方案

output = min + (rand() % static_cast<int>(max - min + 1))

除非范围的大小是2的幂，否则此方法都会产生有偏差的非均匀分布数，而与的质量无关rand()。有关此方法质量的全面测试，请阅读此内容。

最简单（因此也最好）的C ++（使用2011标准）的答案是

#include <random>

std::random_device rd;     // only used once to initialise (seed) engine
std::mt19937 rng(rd());    // random-number engine used (Mersenne-Twister in this case)
std::uniform_int_distribution<int> uni(min,max); // guaranteed unbiased

auto random_integer = uni(rng);

无需重新发明轮子。无需担心偏见。无需担心将时间用作随机种子。

如果您的编译器支持C ++ 0x，并且可以选择使用它，那么新的标准<random>标头可能会满足您的需求。它具有高质量uniform_int_distribution，可以接受最小和最大范围（包括您所需要的范围），并且您可以在各种随机数生成器中进行选择以插入该分布。

这是生成int在[-57，365]中均匀分布的一百万个随机数的代码。我已经使用了新的std <chrono>工具为它计时，因为您提到性能是您的主要关注点。

#include <iostream>
#include <random>
#include <chrono>

int main()
{
    typedef std::chrono::high_resolution_clock Clock;
    typedef std::chrono::duration<double> sec;
    Clock::time_point t0 = Clock::now();
    const int N = 10000000;
    typedef std::minstd_rand G;
    G g;
    typedef std::uniform_int_distribution<> D;
    D d(-57, 365);
    int c = 0;
    for (int i = 0; i < N; ++i) 
        c += d(g);
    Clock::time_point t1 = Clock::now();
    std::cout << N/sec(t1-t0).count() << " random numbers per second.\n";
    return c;
}

对我来说（2.8 GHz Intel Core i5）可以打印出：

每秒2.10268e + 07随机数。

您可以通过将int传递给它的构造函数来为生成器设置种子：

    G g(seed);

如果您以后发现int不满足您的发行范围，则可以通过将此类更改uniform_int_distribution（例如long long）来解决：

    typedef std::uniform_int_distribution<long long> D;

如果您以后发现minstd_rand生成器的质量不够高，也可以很容易地将其替换掉。例如：

    typedef std::mt19937 G;  // Now using mersenne_twister_engine

对随机数生成器具有单独的控制，并且随机分布可以完全解放。

我还计算了（未显示）此分布的前四个“矩”（使用minstd_rand），并将它们与理论值进行了比较，以试图量化分布的质量：

min = -57
max = 365
mean = 154.131
x_mean = 154
var = 14931.9
x_var = 14910.7
skew = -0.00197375
x_skew = 0
kurtosis = -1.20129
x_kurtosis = -1.20001

（x_前缀表示“预期”）

让我们将问题分为两个部分：

• 生成一个n介于0到（max-min）之间的随机数。
• 在该号码上加上分钟

第一部分显然是最难的。假设rand（）的返回值是完全统一的。使用取模将给第一个(RAND_MAX + 1) % (max-min+1)数字增加偏差。因此，如果我们可以神奇地更改RAND_MAX为RAND_MAX - (RAND_MAX + 1) % (max-min+1)，就不会再有任何偏差。

事实证明，如果我们愿意允许伪不确定性进入算法的运行时间，则可以使用这种直觉。每当rand（）返回一个太大的数字时，我们只要求另一个随机数，直到得到一个足够小的数字。

现在，运行时间以几何形状分布，具有期望值1/p，其中p指的是第一次尝试获得足够小的数字的概率。由于RAND_MAX - (RAND_MAX + 1) % (max-min+1)始终小于(RAND_MAX + 1) / 2，我们知道p > 1/2，因此对于任何范围，预期的迭代次数将始终小于两次。使用这种技术，应该可以在不到一秒钟的时间内在标准CPU上生成数千万个随机数。

编辑：

尽管以上在技术上是正确的，但DSimon的答案在实践中可能更有用。您不应该自己实现这些东西。我已经看到了很多拒绝采样的实现，通常很难看到它是否正确。

如何在梅森难题？Boost实现非常易于使用，并且在许多实际应用中都经过了良好的测试。我已经在一些学术项目中使用过它，例如人工智能和进化算法。

在他们的示例中，他们制作了一个简单的功能来滚动六边形模具：

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/variate_generator.hpp>

boost::mt19937 gen;

int roll_die() {
    boost::uniform_int<> dist(1, 6);
    boost::variate_generator<boost::mt19937&, boost::uniform_int<> > die(gen, dist);
    return die();
}

哦，这是该生成器的更多附加功能，以防万一您不相信应该在劣等的产品上使用它rand()：

Mersenne Twister是松本诚和西村隆司发明的“随机数”生成器。他们的网站包含该算法的众多实现。

本质上，梅森扭曲器是一个非常大的线性反馈移位寄存器。该算法对19,937位种子进行操作，该种子存储在由624个元素组成的32位无符号整数数组中。值2 ^ 19937-1是梅森素数；操纵种子的技术基于较旧的“扭曲”算法-因此被称为“ Mersenne Twister”。

Mersenne Twister的一个吸引人的方面是它使用二进制运算（而不是费时的乘法）来生成数字。该算法的周期也很长，粒度也很好。对于非加密应用程序，它既快速又有效。

int RandU(int nMin, int nMax)
{
    return nMin + (int)((double)rand() / (RAND_MAX+1) * (nMax-nMin+1));
}

这是32768个整数到（nMax-nMin + 1）个整数的映射。如果（nMax-nMin + 1）很小（根据您的要求），则映射将非常好。但是请注意，如果（nMax-nMin + 1）大，则映射将不起作用（例如，您无法将32768值映射到30000值的概率相等）。如果需要这样的范围，则应使用32位或64位随机源，而不是15位的rand（），或忽略超出范围的rand（）结果。

这是一个无偏见的版本，它在中生成数字[low, high]：

int r;
do {
  r = rand();
} while (r < ((unsigned int)(RAND_MAX) + 1) % (high + 1 - low));
return r % (high + 1 - low) + low;

如果您的范围相当小，则没有理由在do循环中缓存比较的右侧。

我建议使用Boost.Random库，它非常详细且文档齐全，可让您显式指定所需的分布，并且在非加密方案中，实际上可以胜过典型的C库rand实现。

假设min和max是int值，[和]表示包括此值，（和）表示不包括此值，使用c ++ rand（）使用上述方法获得正确的值

参考：对于（）[]定义，请访问：

https://zh.wikipedia.org/wiki/间隔（数学）

对于rand和srand函数或RAND_MAX定义，请访问：

http://en.cppreference.com/w/cpp/numeric/random/rand

[最小，最大]

int randNum = rand() % (max - min + 1) + min

（最小，最大）

int randNum = rand() % (max - min) + min + 1

[最小，最大）

int randNum = rand() % (max - min) + min

（最小，最大）

int randNum = rand() % (max - min - 1) + min + 1

在该线程拒绝采样中已经讨论过，但是我想提出一个基于上述事实的优化方法，该方法rand() % 2^something不会引入任何偏差。

该算法非常简单：

• 计算大于间隔长度2的最小幂
• 在“新”间隔中随机分配一个数字
• 如果该数字小于原始间隔的长度，则返回该数字
  • 否则拒绝

这是我的示例代码：

int randInInterval(int min, int max) {
    int intervalLen = max - min + 1;
    //now calculate the smallest power of 2 that is >= than `intervalLen`
    int ceilingPowerOf2 = pow(2, ceil(log2(intervalLen)));

    int randomNumber = rand() % ceilingPowerOf2; //this is "as uniform as rand()"

    if (randomNumber < intervalLen)
        return min + randomNumber;      //ok!
    return randInInterval(min, max);    //reject sample and try again
} 

这尤其适用于较小的时间间隔，因为2的乘方将“接近”实际时间间隔的长度，因此未命中的次数将减少。

PS
显然，避免递归会更有效（无需一遍又一遍地计算对数上限。）但是我认为此示例更易读。

请注意，在大多数建议中，您从rand（）函数获得的初始随机值（通常从0到RAND_MAX）被简单地浪费了。您只能在其中创建一个随机数，而有一个声音程序可以为您提供更多。

假设您想要整数随机数的[min，max]区域。我们从[0，max-min]开始

取底b = max-min + 1

从代表从b的rand（）获得的数字开始。

这样，您便有了floor（log（b，RAND_MAX）），因为除可能的最后一位外，基数b中的每个数字都表示范围为[0，max-min]的随机数。

当然，对于每个随机数r + min，最终移至[min，max]很简单。

int n = NUM_DIGIT-1;
while(n >= 0)
{
    r[n] = res % b;
    res -= r[n];
    res /= b;
    n--;
}

如果NUM_DIGIT是您可以提取的以b为底的位数，即

NUM_DIGIT = floor(log(b,RAND_MAX))

那么以上内容是从提供b <RAND_MAX的一个RAND_MAX随机数中提取0到b-1的NUM_DIGIT随机数的简单实现。

公式非常简单，因此请尝试使用此表达式，

 int num = (int) rand() % (max - min) + min;  
 //Where rand() returns a random number between 0.0 and 1.0

如果我没有记错的话，下面的表达应该是公正的：

std::floor( ( max - min + 1.0 ) * rand() ) + min;

我在这里假设rand（）为您提供一个介于0.0和1.0之间的随机值，不包括1.0，并且max和min是整数，且min <max。