Порт Случайного генератора от C до Java?

действительно ли кто-либо может портировать это на Java? Как это работает, когда Вы только имеете числа со знаком в наличии?

Никакое Напряжение! a=18782, таким образом, самое большое t могло когда-либо быть, не является достаточно большим для порождения подписанный по сравнению с неподписанными проблемами. Необходимо было бы "обновить" результат использования Q к значению, равному 32-разрядному неподписанному числу перед использованием его где угодно. например, если бы Q int (32-разрядный подписанный) затем, необходимо было бы сделать это перед использованием его в t=a*Q[i]+c оператор, например,

t=a*(((long)Q[i])&0xffffffffL)+c

где это (((длинный) Q [я]) & 0xffffffffL) бизнес продвигает Q [я] 64-разрядный # и гарантирует, что его высокие 32 бита являются 0. (редактирование:Примечание: Вам нужен 0xffffffffL здесь. Java делает неправильную вещь при использовании 0xffffffff кажется, что это "оптимизирует" себя к неправильному ответу & Вы получаете отрицательное число, если Q [я] высоко бит равняется 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());
        }
    }
};