随机生成器从C到Java的端口？

大多数情况下，在 Java 中不需要使用较大的数值类型来模拟无符号类型。

对于加法，减法，乘法，左移，逻辑运算，相等和强制转换为较小的数字类型，无论操作数是有符号还是无符号都无关紧要，结果无论如何都是相同的，被视为位模式。

对于已签名，>>>转换为正确的用法>>。

对于签名的投射到更大的类型，只需这样做。

用于从较小类型到长期使用的无符号投射，并且对于较小的类型，请使用长类型的掩码。例如，从短到长：s & 0xffffL。

对于从较小类型到 int 的无符号转换，请使用 & 具有 int 类型的掩码。例如，字节到整数：b和0xff。

否则，请像 int 大小写一样，并在顶部应用强制。例如，字节到短：（短）（b和0xff）。

对于比较运算符<等和划分，最简单的方法是转换为更大的类型并在那里执行操作。但也有其他选择，例如，在添加适当的偏移量后进行比较。

任何人都可以将其移植到Java吗？当您只有可用的签名号码时，这是如何工作的？

没有压力！ 因此，有史以来最大的可能还不够大，无法导致有符号与未签名的问题。在任何地方使用Q之前，您必须将使用Q的结果“升级”为等于32位无符号数字的值。例如，如果Q是（32位有符号），那么在语句中使用它之前，您必须执行此操作，例如a=18782tintt=a*Q[i]+c

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

其中，此（（（long）Q[i]）&0xffffffffL）业务将Q[i]提升为64位#，并确保其高32位为0。（编辑：注意：你需要0xffffffl在这里。如果你使用0xffffffff，Java做了错误的事情，它似乎“优化”了错误的答案，如果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());
        }
    }
};