Порт случайного генератора от C до Java?
Джордж Марсалья написал отличный генератор случайных чисел, который является чрезвычайно быстрым, простым и имеет гораздо более высокий период, чем Мерсенн Твистер. Вот код с описанием:
хороший генератор случайных чисел 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? Как это работает, когда у вас есть только подписанные номера?
EDIT: спасибо всем за быстрые ответы! Для первых 100 миллионов чисел этот код java, похоже, дает тот же результат, что и код C. Это в 3 раза быстрее, чем java Java.утиль.Случайность.
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;
}
}
6 ответов
может ли кто-нибудь перенести это на Java? Как эта работа, когда вы только подписали номера доступны?
Никакого Стресса! a=18782
поэтому большая t
может когда-либо быть недостаточно большим, чтобы вызвать подписанные и неподписанные проблемы. Вам придется "обновить" результат использования 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. (edit: Примечание: вам нужен 0xffffffffL здесь. Java делает неправильно, если вы используете 0xffffffff, кажется, что он "оптимизирует" себя до неправильного ответа, и вы получаете отрицательное число, если высокий бит Q[i] равен 1.)
вы должны иметь возможность проверить это, запустив алгоритмы на C++ и Java для сравнения выходов.
edit: вот снимок на него. Я попытался запустить его на 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.
для сложения, вычитания, умножения, сдвига влево, логических операций, равенства и приведение к меньшему числовому типу неважно, операнды signed или unsigned, результат будет одинаковым независимо от того, рассматривается как битовый шаблон.
для смещения вправо используйте >> для подписанного, > > > для неподписанного.
за подписью кастинг для большего типа просто сделайте это.
для беззнакового литья от меньшего типа до длительного использования & с маской типа long для меньшего типа. Е. Г., коротких до длинных: индекс S & 0xffffL.
для беззнакового литья от меньшего типа к int используйте & с маской типа int. Е. Г., Byte к int: б & значение 0xFF.
в противном случае сделайте как в случае int и примените литье сверху. Например, byte to short: (short) (b & 0xff).
для операторов сравнения
Если вы реализуете RNG в Java, лучше всего подкласс java.утиль.Random класс и более-ездить защищенный next (int) метод(ваш RNG затем является заменой для Java.утиль.Случайный.) Следующий метод (int) связан со случайно сгенерированными битами, а не с тем, что могут представлять эти биты. Другие (общедоступные) методы java.утиль.Random используйте эти биты для построения случайных значений различных типов.
чтобы обойти отсутствие беззнаковых типов Java, вы обычно храните числа в большем типе переменной (поэтому шорты обновляются до ints, ints до long). Поскольку вы используете длинные переменные здесь, вам придется подойти к BigInteger, что, вероятно, разрушит любое увеличение скорости, которое вы получаете из алгоритма.
вы можете использовать подписанные номера при условии, что значения не переполняются...например, long в java - это 64-битное целое число со знаком. Однако целью этого алгоритма, похоже, является использование 64-битного значения без знака, и если это так, я думаю, вам не повезет с основными типами.
вы можете использовать целые числа multiprecision, предоставленные в библиотеках классов java (BigInteger). Или вы можете реализовать свой собственный 64-битный беззнаковый тип в качестве объекта, содержащего два Java представляют собой наименее значимые и наиболее значимые слова (но вам придется самостоятельно выполнять основные арифметические операции в классе).