Порт генератора случайных чисел от C до Java?

Ответ 1

Может ли кто-нибудь передать это на 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.)

Вы должны убедиться в этом, выполнив алгоритмы на С++ и Java для сравнения выходов.

edit: вот выстрел в него. Я попытался запустить его на С++ и Java для N = 100000; они оба совпадают. Извинения, если я использовал плохие Java-идиомы, я до сих пор довольно новичок в Java.

С++:

// 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: (медленнее, чем скомпилированный С++, но он соответствует 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());
        }
    }
};

Ответ 2

В большинстве случаев нет необходимости использовать более крупные числовые типы для имитации неподписанных типов в Java.

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

Для переключения на правильное использование → для подписанных, → > для без знака.

Для подписанного каста большего размера просто сделайте это.

Для беззнакового каста от меньшего типа до длительного использования и с маской типа long для меньшего типа. Например, от короткого до длинного: s и 0xffffL.

Для беззнакового каста от меньшего типа до использования int и с маской типа int. Например, byte to int: b и 0xff.

В противном случае сделайте так, как в случае int, и примените листинг сверху. Например, байт на короткий: (короткий) (b и 0xff).

Для операторов сравнения < и т.д., а разделение проще всего сделать для более крупного типа и выполнить операцию там. Но существуют и другие варианты, например. выполните сравнения после добавления соответствующего смещения.

Ответ 3

Если вы внедряете RNG в Java, лучше всего подклассы java.util.Random класс и переезд защищенный метод next(int) (ваш RNG является заменой для java.util.Random). Следующий (int) метод связан с произвольно генерируемыми битами, а не с теми значениями, которые могут представлять эти биты. Другие (общедоступные) методы java.util.Random используют эти биты для построения случайных значений разных типов.

Ответ 4

Чтобы обойти Java без неподписанных типов, вы обычно храните числа в более крупном типе переменной (поэтому shorts получают обновление до ints, ints long). Поскольку вы используете длинные переменные здесь, вам нужно будет подойти к BigInteger, что, вероятно, повредит любой прирост скорости, который вы выходите из алгоритма.

Ответ 5

Как быстрая точка отсчета, которая может (или не может) помочь вам, я нашел эту ссылку:

http://darksleep.com/player/JavaAndUnsignedTypes.html

Ответ 6

Вы можете использовать подписанные числа, если значения не переполняются... например, long в java - это 64-разрядное целое число со знаком. Однако намерение в этом алгоритме состоит в использовании 64-разрядного значения без знака, и если это так, я думаю, вам не повезло бы с базовыми типами.

Вы можете использовать целые числа multiprecision, представленные в библиотеках классов java (BigInteger). Или вы можете реализовать свой собственный 64-разрядный неподписанный тип как объект, содержащий два java longs для представления наименее значимых и наиболее значимых слов (но вам придется реализовать основные арифметические операции самостоятельно в классе).