Port de générateur Aléatoire de C à Java?

Quelqu'un peut-port ce de Java? Comment
ce travail quand vous n'avez signé
numéros disponibles?

Pas De Stress! a=18782 de sorte que le plus grand t pourrait jamais l'être n'est pas assez grande pour causer signé vs non signé problèmes. Vous auriez de "mise à niveau" le résultat de l'utilisation de Q à une valeur égale à un non signé de 32 bits numéro avant de l'utiliser n'importe où. par exemple, si Q est un int (signé 32 bits) alors que vous avez à faire cela avant de l'utiliser dans le t=a*Q[i]+c déclaration, par exemple

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

où cette (((long)Q[i])&0xffffffffL) favorise Q[i] 64-bits # et veille à sa haute 32 bits sont à 0. (edit: REMARQUE: vous devez 0xffffffffL ici. Java n'est pas une bonne chose si vous utilisez 0xffffffff, il semble que cela "optimise" lui-même à la mauvaise réponse & vous obtenez un nombre négatif si Q[i]'s high bit est à 1.)

Vous devriez être en mesure de vérifier cela en exécutant des algorithmes en C++ et Java pour comparer les résultats.

edit: voici une chance. J'ai essayé de courir en C++ et Java pour N=100000; ils les deux match. Toutes mes excuses si j'ai utilisé le mauvais Java idiomes, je suis encore assez nouveau pour 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: (plus lent que compilé en C++, mais il correspond pour 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());
}
}
};

OriginalL'auteur Jason S

Si vous êtes à la mise en œuvre d'un générateur de nombres aléatoires en Java, il est préférable de sous-classe de la java.util.Aléatoire de la classe et de l'emporter sur les protégés prochaine(int) méthode (votre RNG est alors une baisse-dans le remplacement pour java.util.Aléatoire). La prochaine(int) méthode concerne généré de façon aléatoire de bits, pas ce que vales ces bits peut représenter. Les autres (public) méthodes de java.util.Aléatoire l'utilisation de ces bits pour construire aléatoire des valeurs de types différents.

OriginalL'auteur Dan Dyer

Juste un petit point de référence qui peut (ou pas) de vous aider, j'ai trouvé ce lien:

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

OriginalL'auteur Joel Marcey