Порт генератора случайных чисел с C на Java?
https://stackoverflow.com/questions/397867
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Джордж Марсалья написал превосходный генератор случайных чисел, который чрезвычайно быстр, прост и имеет гораздо более высокий период, чем у Mersenne Twister.Вот код с описанием:
хороший генератор случайных чисел C
Я хотел портировать код CMWC4096 на Java, но он использует несколько неподписанных типов данных, поэтому я не уверен, как это сделать правильно.Вот полный C-код:
/* choose random initial c<809430660 and */
/* 4096 random 32-bit integers for Q[] */
static unsigned long Q[4096],c=362436;
unsigned long CMWC4096(void) {
unsigned long long t, a=18782LL;
static unsigned long i=4095;
unsigned long x,r=0xfffffffe;
i = (i+1) & 4095;
t = a*Q[i] + c;
c = (t>>32);
x = t + c;
if (x < c) {
x++;
c++;
}
return (Q[i] = r - x);
}
Кто-нибудь может перенести это на Java?Как это работает, если у вас доступны только подписанные номера?
Редактировать: Спасибо всем за быстрые ответы!Для первых 100 миллионов чисел этот java-код, похоже, выдает тот же результат, что и C-код.Это в 3 раза быстрее, чем Java java.util.Случайный.
public class ComplimentaryMultiplyWithCarryRandom {
/**
* Choose 4096 random 32-bit integers
*/
private long[] Q;
/**
* choose random initial c<809430660
*/
private long c = 362436;
private int i;
public ComplimentaryMultiplyWithCarryRandom() {
Random r = new Random(1);
Q = new long[4096];
// TODO initialize with real random 32bit values
for (int i = 0; i < 4096; ++i) {
long v = r.nextInt();
v -= Integer.MIN_VALUE;
Q[i] = v;
}
i = 4095;
}
int next() {
i = (i + 1) & 4095;
long t = 18782 * Q[i] + c;
c = t >>> 32;
long x = (t + c) & 0xffffffffL;
if (x < c) {
++x;
++c;
}
long v = 0xfffffffeL - x;
Q[i] = v;
return (int) v;
}
}
Решение
Кто-нибудь может перенести это на Java?Как это работает, когда у вас есть только подписанные доступные номера?
Никакого стресса! a=18782 итак, самый большой t может когда-либо быть недостаточно большим, чтобы вызвать signed vs.неподписанные проблемы.Вам пришлось бы "обновить" результат использования Q до значения, равного 32-разрядному числу без знака, прежде чем использовать его где бы то ни было.например ,если Q - это int (32-разрядный подписанный), то вам пришлось бы сделать это перед использованием в t=a*Q[i]+c утверждение, например
t=a*(((long)Q[i])&0xffffffffL)+c
где этот (((длинный)Q[i])&0xffffffffL) бизнес переводит Q [i] в 64-разрядный # и гарантирует, что его старшие 32 бита равны 0.(редактировать:ПРИМЕЧАНИЕ:здесь вам нужен 0xffffffffL .Java делает неправильную вещь, если вы используете 0xffffffff, кажется, что она "оптимизирует" себя до неправильного ответа, и вы получаете отрицательное число, если старший бит Q [i] равен 1.)
Вы должны быть в состоянии убедиться в этом, запустив алгоритмы на C ++ и Java для сравнения выходных данных.
Редактировать:вот пример того, как это сделать.Я попытался запустить его на C ++ и Java для N = 100000;они оба совпадают.Прошу прощения, если я использовал плохие идиомы Java, я все еще довольно новичок в Java.
C++:
// marsaglia2003.cpp
#include <stdio.h>
#include <stdlib.h> // for atoi
class m2003
{
enum {c0=362436, sz=4096, mask=4095};
unsigned long Q[sz];
unsigned long c;
short i;
public:
m2003()
{
// a real program would seed this with a good random seed
// i'm just putting in something that makes the output interesting
for (int j = 0; j < sz; ++j)
Q[j] = j + (j << 16);
i = 4095;
c = c0;
}
unsigned long next()
{
unsigned long long t, a=18782LL;
unsigned long x;
unsigned long r=0xfffffffe;
i = (i+1)&mask;
t=a*Q[i]+c;
c=(unsigned long)(t>>32);
x=(unsigned long)t + c;
if (x<c)
{
x++;
c++;
}
return (Q[i]=r-x);
}
};
int main(int argc, char *argv[])
{
m2003 generator;
int n = 100;
if (argc > 1)
n = atoi(argv[1]);
for (int i = 0; i < n; ++i)
{
printf("%08x\n", generator.next());
}
return 0;
}
java - язык:(медленнее, чем скомпилированный C ++, но он соответствует для N = 100000)
// Marsaglia2003.java
import java.util.*;
class Marsaglia2003
{
final static private int sz=4096;
final static private int mask=4095;
final private int[] Q = new int[sz];
private int c=362436;
private int i=sz-1;
public Marsaglia2003()
{
// a real program would seed this with a good random seed
// i'm just putting in something that makes the output interesting
for (int j = 0; j < sz; ++j)
Q[j] = j + (j << 16);
}
public int next()
// note: returns a SIGNED 32-bit number.
// if you want to use as unsigned, cast to a (long),
// then AND it with 0xffffffffL
{
long t, a=18782;
int x;
int r=0xfffffffe;
i = (i+1)&mask;
long Qi = ((long)Q[i]) & 0xffffffffL; // treat as unsigned 32-bit
t=a*Qi+c;
c=(int)(t>>32);
// because "a" is relatively small this result is also small
x=((int)t) + c;
if (x<c && x>=0) // tweak to treat x as unsigned
{
x++;
c++;
}
return (Q[i]=r-x);
}
public static void main(String args[])
{
Marsaglia2003 m2003 = new Marsaglia2003();
int n = 100;
if (args.length > 0)
n = Integer.parseInt(args[0]);
for (int i = 0; i < n; ++i)
{
System.out.printf("%08x\n", m2003.next());
}
}
};
Другие советы
В большинстве случаев нет необходимости использовать большие числовые типы для имитации неподписанных типов в Java.
Для сложения, вычитания, умножения, сдвига влево, логических операций, равенства и приведения к меньшему числовому типу не имеет значения, являются ли операнды знаковыми или беззнаковыми, результат будет тем же независимо от этого, рассматриваемый как битовый шаблон.
Для переключения вправо используйте >> для подписанных, >>> для неподписанных.
Для приведения с подписью к более крупному типу просто сделайте это.
Для преобразования без знака из меньшего типа в длинный используйте & с маской типа long для меньшего типа.Например, от короткого к длинному:s & 0xffffL.
Для приведения без знака из меньшего типа в int используйте & с маской типа int.Например, байт в int:b & 0xff.
В противном случае сделайте, как в случае int, и примените приведение сверху.Например, байт для короткого замыкания:(короткий) (b & 0xff).
Для операторов сравнения < и т.д.а деление проще всего привести к более крупному типу и выполнить операцию там.Но существуют и другие варианты, напримервыполняйте сравнения после добавления соответствующего смещения.
Если вы реализуете RNG на Java, лучше всего подклассировать java.утилита.Случайный класс и перегонять защищенные следующий (int) метод (в этом случае ваш RNG является встроенной заменой java.util.Случайный).Следующий метод (int) связан со случайно сгенерированными битами, а не с тем, какие значения эти биты могут представлять.Другие (общедоступные) методы java.util.Random используют эти биты для построения случайных значений разных типов.
Чтобы обойти отсутствие в Java беззнаковых типов, вы обычно храните числа в большем типе переменной (поэтому shorts обновляется до целых чисел, а ints - до длинных).Поскольку вы используете здесь длинные переменные, вам придется перейти к BigInteger , что, вероятно, сведет на нет любой прирост скорости, который вы получаете от алгоритма.
Просто в качестве краткого ориентира, который может (а может и нет) помочь вам, я нашел эту ссылку:
Вы можете использовать числа со знаком при условии, что значения не переполняются ... например, long в java - это 64-битное целое число со знаком.Однако цель этого алгоритма, по-видимому, состоит в том, чтобы использовать 64-битное значение без знака, и если это так, я думаю, вам не повезло бы с базовыми типами.
Вы могли бы использовать целые числа с многозначностью, предоставляемые в библиотеках классов Java (Большой ИнтЕгратор).Или вы могли бы реализовать свой собственный 64-разрядный тип без знака в виде объекта, содержащего две длины java для представления наименее значимых и наиболее значимых слов (но вам пришлось бы самостоятельно выполнять основные арифметические операции в классе).
