алгоритм — псевдослучайное распределение, которое гарантирует все возможные перестановки последовательности значений

Случайный вопрос.

Я пытаюсь создать программу, которая будет генерировать псевдослучайное распределение. Я пытаюсь найти правильный псевдослучайный алгоритм для моих нужд. Это мои проблемы:

1) Мне нужен один вход, чтобы генерировать один и тот же вывод каждый раз, когда он используется.

2) Он должен быть достаточно случайным, чтобы человек, который просматривает выходной сигнал с входа 1, не видел никакой связи между ним и выходным сигналом с входа 2 (и т. Д.), Но не нужно, чтобы он был криптографически безопасным или действительно случайным.

3) Выходное значение должно быть числом от 0 до (29 ^ 3200) -1, причем каждое возможное целое число в этом диапазоне является возможным и равным (или близким к нему) вероятным выходным значением.

4) Я хотел бы иметь возможность гарантировать, что каждая возможная перестановка последовательностей из 410 выходов также является потенциальным выходом последовательных входов. Другими словами, все возможные группировки 410 целых чисел от 0 до (29 ^ 3200) -1 должны быть потенциальными выходами последовательных входов.

5) Я бы хотел, чтобы функция была обратимой, чтобы я мог взять целое число или серию целых чисел и сказать, какой вход или серия входов даст такой результат.

Метод, который я разработал до сих пор, состоит в том, чтобы выполнить ввод через простую последовательность halson:

boost::multiprecision::mpz_int denominator = 1;
boost::multiprecision::mpz_int numerator = 0;

while (input>0) {
denominator *=3;
numerator = numerator * 3 + (input%3);
input = input/3;
}

и умножьте результат на 29 ^ 3200. Он соответствует требованиям 1-3, но не 4. И он обратим только для отдельных целых чисел, а не для рядов (так как не все последовательности могут быть получены им). Я работаю в C ++, используя повышение точности.

Будем весьма благодарны за любые советы, которые мне могут дать относительно способа создания случайного распределения, отвечающего этим требованиям, или просто за класс алгоритмов, которые стоит изучить с этой целью. Заранее благодарю за рассмотрение моего вопроса.

—-ОБНОВИТЬ—-

Поскольку несколько комментаторов были сосредоточены на размере рассматриваемых чисел, я просто хотел прояснить, что я осознаю практические проблемы, возникающие при работе с такими наборами, но при задании этого вопроса меня интересует только теоретический или концептуальный подход к проблема — например, представьте себе работу с намного меньшим набором целых чисел, например от 0 до 99, и перестановками наборов из 10 выходных последовательностей. Как бы вы разработали алгоритм для удовлетворения этих пяти условий: 1) входные данные являются детерминированными, 2) кажутся случайными (по крайней мере, для человеческого глаза), 3) каждое целое число в диапазоне является возможным выходным значением, 4) не только все значения, но также все перестановки последовательностей значений являются возможными выходами, 5) функция является обратимой.

—второе обновление —

Большое спасибо @Severin Pappadeux. Мне удалось перевернуть lcg. Я подумал, что добавлю немного о том, что я сделал, чтобы, надеюсь, облегчить это любому, кто увидит это в будущем. Прежде всего, это отличные источники по инвертированию модульных функций:

https://www.khanacademy.org/computing/computer-science/cryptography/modarithmetic/a/modular-inverses

https://www.khanacademy.org/computer-programming/discrete-reciprocal-mod-m/6253215254052864

Если вы возьмете уравнение next = ax + c% m, используя следующий код со своими значениями для a и m, выведите евклидовы уравнения, которые вам нужно найти, а также значение ainverse:

    int qarray[12];
qarray[0]=0;
qarray[1]=1;
int i =2;
int reset = m;
while (m % a >0) {
int remainder=m%a;
int quotient=m/a;
std::cout << m << " = " << quotient << "*" << a << " + " << remainder << "\n";
qarray[i] =qarray[i-2]-(qarray[i-1]*quotient);
m=a;
a=remainder;
i++;
}
if (qarray[i-1]<0) {qarray[i-1]+=reset;}
std::cout << qarray[i-1] << "\n";

Другое дело, что мне потребовалось некоторое время, чтобы понять, что, если вы получите отрицательный результат, вы должны добавить к нему m. Вы должны добавить аналогичный термин в ваше новое уравнение:

prev = (ainverse(next-c))%m;
if (prev<0) {prev+=m;}

Я надеюсь, что это поможет любому, кто решится пойти по этому пути в будущем.