Как получить n-е число в последовательности rand () напрямую, не вызывая rand () n раз?

Сделайте свой собственный ранд и сохраните по одному в каждом классе. Конечно, это самый слабый ГПСЧ. Дело в том, что у вас может быть одновременно несколько активных ГПСЧ.

class Rand {
    int seed;
    const int a = 1103515245;
    const int c = 12345;
public:
    Rand();
    void srand( int );
    int rand();
};

Rand::Rand() : seed(123456789) {}

void Rand::srand( int s ) { seed = s; }

int Rand::rand()
{
  seed = a * seed + c;
  return seed;
}

OP спрашивает: «Я использую rand в разных классах с разными начальными числами». У каждого экземпляра Rand есть собственное семя. Поэтому поместите экземпляр Rand в каждый объект, которому требуется собственное семя.

Все C ++ 11 PRNG имеют "discard", например

#include <random>
#include <iostream>

int main() {
    std::mt19937 rng;
    static const size_t distance = 5;

    rng.seed(0);
    rng.discard(distance);
    std::cout << "after discard 5: " << rng() << '\n';

    rng.seed(0);
    for (size_t i = 0; i <= distance; ++i) {
        std::cout << i << ": " << rng() << '\n';
    }
}

http://ideone.com/0zeRNq

after discard 5: 3684848379
0: 2357136044
1: 2546248239
2: 3071714933
3: 3626093760
4: 2588848963
5: 3684848379

Используйте 1_. С этой функцией семя не является глобальным и неявным. Вы передаете начальное число для явного использования, и функция обновляет его по мере вычисления следующего случайного числа. Таким образом, поток случайных чисел каждого класса не зависит от других.

Каждый объект или каждый класс (в зависимости от потребностей вашего дизайна) будет хранить начальное значение в переменной unsigned int. Это инициализирует его; для объектов - в методе init; для занятий в +initialize. Вы можете использовать время или, возможно, /dev/random в качестве начального значения. Если вы инициализируете несколько таких объектов или классов в тесной последовательности, то использование времени - плохая идея, поскольку все они могут происходить в «одно и то же» время (в пределах разрешения используемых вами часов).

После этого каждый раз, когда вам нужен случайный номер, вы звоните rand_r(&yourSeedVariable). Это вернет псевдослучайное значение, вычисленное только из переданного начального числа, без использования какого-либо неявного или глобального состояния. Он использует тот же алгоритм, что и rand(). Он также обновляет начальную переменную, так что при следующем вызове будет выдано следующее случайное число в этой последовательности.

Любой другой объект или класс, использующий тот же метод, будет иметь независимую случайную последовательность. Их вызовы rand_r() не повлияют на вызовы этого объекта или класса, а вызовы этого объекта или класса на них не повлияют. То же самое для всех абонентов rand().

Чтобы уточнить немного дальше. Вы сказали в одной из правок на свой вопрос:

Причина, по которой я хочу «перейти» к n-му члену, заключается в том, что я использую rand в разных классах с разными начальными числами и продолжаю прыгать вперед и назад между каждым классом. Я хочу, чтобы последовательность в каждом классе продолжалась с того места, где она была остановлена, вместо того, чтобы каждый раз начинать с первого числа.

Я обращаюсь к этой потребности своим предложением. Мое предложение не отвечает на ваш вопрос в исходной формулировке. Это не позволяет получить * n * ое число в псевдослучайной последовательности. Вместо этого он позволяет вам использовать отдельные последовательности в отдельных частях вашего кода, чтобы они не мешали друг другу.

Вам нужен произвольный доступ к набору псевдослучайных потоков. Вы можете получить его, переключившись с std::rand() на блочный шифр в режиме счетчика (CTR) в качестве генератора псевдослучайных чисел. Чтобы прочитать последовательные псевдослучайные числа, зашифруйте последовательные числа в открытом виде. Чтобы читать в другом порядке, зашифруйте числа из того же диапазона в определенном порядке. Тогда каждый класс будет иметь собственное семя, состоящее из ключа и начального значения.

Например, начальное значение одного класса может быть 8675309, а начальное значение - 8008135. Чтобы считать последовательные случайные числа, зашифруйте каждое из 8008136, 8008137, 8008138, 8008139, 8008140, ... этим ключом. Чтобы считать 17-е число в этой последовательности, зашифруйте (8008135 + 17) = 8008152.

Вы можете использовать функцию 1: 1 хеширования на 32-битном или 64-битном счетчике. Для своего хэша вы можете адаптировать любой метод, который PRNG будет использовать в качестве функции обратной связи и / или темперирования, например, этот из xorshift, страница:

uint64_t state;

void srand(uint64_t seed) {
  state = seed;
}

uint64_t hash(uint64_t x) {
  x ^= x >> 12;
  x ^= x << 25;
  x ^= x >> 27;
  return x * 2685821657736338717ull;
}

uint32_t rand(void) {
  return hash(state++) >> 32;
}

uint32_t rand(uint32_t n) {
  return hash(n) >> 32;
}

Главное в PRNG заключается в том, что (в обычных быстрых реализациях) следующее значение зависит от предыдущего. Так что нет, вы не можете получить N-е значение, не вычислив все предыдущие N-1.

Короткий ответ: нет.

Более длинный ответ: псевдослучайные серии являются «случайными» в том смысле, что компьютер не может предварительно вычислить серию, не зная предварительно вычисленный элемент (или начальное число), но являются «псевдо» в том смысле, что последовательность воспроизводима с использованием того же начального числа.

При использовании Google-fu LSFR требует конечного числа состояний. ГПСЧ, которые вы пытаетесь получить, - нет.