生成随机 64 位整数

发布于 2024-12-15 12:31:41 字数 257 浏览 1 评论 0原文

我需要你的帮助，请给我一些建议。从编程珍珠我知道，要生成随机 30 位整数，我们应该这样写：

RAND_MAX*rand()+rand()

但是我可以做什么来生成不是 30 位，而是 64 位随机整数呢？我认为如果我将两个30位整数相乘然后再乘以4位整数，这是非常低效的方法，那么我应该使用什么样的方法呢？我现在正在使用 popcount_1 不同的 64 位方法，我想在随机整数上测试它（我还在测量每个方法完成任务所需的时间）

原文

I need your help and please give me some advice. From programming pearls I know that to generate random 30 bit integer we should write it like this:

RAND_MAX*rand()+rand()

But what could I do for generating not 30, but 64 bit random integer instead? I think that is very inefficient method if I multiply two 30 bit integers and then multiply again 4 bit integer, so what kind of method should I use?
I am using now popcount_1 different method for 64 bit one and I would like to test it on random integers(I am also measuring the time which each one takes to accomplish the task)

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

清风疏影 2024-12-22 12:31:41

首先，我对您发布的 30 位解决方案表示怀疑
整数。 RAND_MAX 本身可以是一个 31 位值，并且 RAND_MAX * rand() + rand() 可能会溢出，产生未定义的行为
（实际上，负值）。

如果您需要的值大于保证最小值 RAND_MAX，或者
就此而言，任何不明显小于
RAND_MAX，唯一的解决方案是使用连续调用
rand()，并组合这些值，但您需要小心地执行此操作，并且
验证结果。（rand() 的大多数实现都使用线性
全等生成器虽然足以完成某些任务，但不能
在这种情况下特别好。）无论如何，类似：（

unsigned 
rand256()
{
    static unsigned const limit = RAND_MAX - RAND_MAX % 256;
    unsigned result = rand();
    while ( result >= limit ) {
        result = rand();
    }
    return result % 256;
}

unsigned long long
rand64bits()
{
    unsigned long long results = 0ULL;
    for ( int count = 8; count > 0; -- count ) {
        results = 256U * results + rand256();
    }
    return results;
}

rand256中的代码旨在消除其他情况
将 RAND_MAX 值映射到 256 个值时不可避免地会出现偏差。）

First, I have my doubts about the solution you post for a 30 bit
integer. RAND_MAX itself could be a 31 bit value, and RAND_MAX * rand() + rand() is likely to overflow, producing undefined behavior
(and in practice, negative values).

If you need a value larger than the guaranteed minimum of RAND_MAX, or
for that matter, anything that isn't significantly smaller than
RAND_MAX, the only solution will be to use successive calls to
rand(), and combine the values, but you need to do this carefully, and
validate the results. (Most implementations of rand() use linear
congruent generators, which while adequate for some tasks, aren't
particularly good in this case.) Anyway, something like:

unsigned 
rand256()
{
    static unsigned const limit = RAND_MAX - RAND_MAX % 256;
    unsigned result = rand();
    while ( result >= limit ) {
        result = rand();
    }
    return result % 256;
}

unsigned long long
rand64bits()
{
    unsigned long long results = 0ULL;
    for ( int count = 8; count > 0; -- count ) {
        results = 256U * results + rand256();
    }
    return results;
}

(The code in rand256 is designed to eliminate the otherwise
unavoidable bias you get when mapping RAND_MAX values to 256 values.)

回复收藏 0 原文

往日情怀 2024-12-22 12:31:41

这可能是一个解决方案，无需乘法：

r30 = RAND_MAX*rand()+rand()
s30 = RAND_MAX*rand()+rand()
t4  = rand() & 0xf

res = (r30 << 34) + (s30 << 4) + t4

This could be a solution, without multiplication:

r30 = RAND_MAX*rand()+rand()
s30 = RAND_MAX*rand()+rand()
t4  = rand() & 0xf

res = (r30 << 34) + (s30 << 4) + t4

回复收藏 0 原文

无畏 2024-12-22 12:31:41

如果 boost 是一个选项，您可以使用增强随机。

回复收藏 0 原文

冷默言语 2024-12-22 12:31:41

随机 64 位 int 本质上是解释为 int 的 64 个随机位。

用随机字节填充长度为 8 的字节数组 (请参见此处）并将它们解释为 int (请参阅此处了解具体方法）。

回复收藏 0 原文

枕梦 2024-12-22 12:31:41

通用解决方案：

template <unsigned long long I> struct log2 {
  static const int result = 1 + log2<I/2>::result;
};
template <> struct log2<1> {
  static const int result = 0;
};

template <typename UINT> UINT genrand() {
  UINT result = 0;
  int bits = std::numeric_limits<UINT>::digits;
  int rand_bits = log2<RAND_MAX>::result;
  while (bits > 0) {
    int r = rand();
    while (r >= (1<<rand_bits)) r = rand(); // Retry if too big.
    result <<= rand_bits;
    result += r;
    bits -= rand_bits;
  }
  return result;
}

使用：unsigned long long R = genrand();。

位计数器跟踪仍需要的位数。

A generic solution:

template <unsigned long long I> struct log2 {
  static const int result = 1 + log2<I/2>::result;
};
template <> struct log2<1> {
  static const int result = 0;
};

template <typename UINT> UINT genrand() {
  UINT result = 0;
  int bits = std::numeric_limits<UINT>::digits;
  int rand_bits = log2<RAND_MAX>::result;
  while (bits > 0) {
    int r = rand();
    while (r >= (1<<rand_bits)) r = rand(); // Retry if too big.
    result <<= rand_bits;
    result += r;
    bits -= rand_bits;
  }
  return result;
}

Use: unsigned long long R = genrand<unsigned long long>();.

The bits counter keeps track of the number of bits still needed.

回复收藏 0 原文