Comment générer un hasard BigInteger valeur en Java?

Utiliser une boucle:

BigInteger randomNumber;
do {
    randomNumber = new BigInteger(upperLimit.bitLength(), randomSource);
} while (randomNumber.compareTo(upperLimit) >= 0);

en moyenne, il faudra moins de deux itérations, et la sélection sera uniforme.

Edit: Si votre RNG est cher, vous pouvez limiter le nombre d'itérations de la façon suivante:

int nlen = upperLimit.bitLength();
BigInteger nm1 = upperLimit.subtract(BigInteger.ONE);
BigInteger randomNumber, temp;
do {
    temp = new BigInteger(nlen + 100, randomSource);
    randomNumber = temp.mod(upperLimit);
} while (s.subtract(randomNumber).add(nm1).bitLength() >= nlen + 100);
//result is in 'randomNumber'

Avec cette version, il est hautement improbable que la boucle est pris plus d'une fois (moins d'une chance sur 2^100, c'est à dire beaucoup moins que la probabilité que la machine hôte spontanément prend feu dans la prochaine seconde qui suit). D'autre part, la mod() opération est coûteuse en termes de calcul, de sorte que cette version est probablement plus lent que le précédent, à moins que le randomSource instance est extrêmement lente.

L'approche la plus simple (par un assez long chemin) serait d'utiliser le spécifiée constructeur pour générer un nombre aléatoire avec le bon nombre de bits (floor(log2 n) + 1), et de le jeter ensuite si il est plus grand que n. Dans le pire des cas possible (par exemple un nombre dans l'intervalle [0, 2ⁿ + 1), vous allez jeter juste moins de la moitié des valeurs que vous créez, en moyenne.

Ici est de savoir comment je le fais dans une classe appelée Generic_BigInteger disponible via:
Andy Turner Générique Code Source de la Page Web

/**
* There are methods to get large random numbers. Indeed, there is a
* constructor for BigDecimal that allows for this, but only for uniform
* distributions over a binary power range.
* @param a_Random
* @param upperLimit
* @return a random integer as a BigInteger between 0 and upperLimit
* inclusive
*/
public static BigInteger getRandom(
Generic_Number a_Generic_Number,
BigInteger upperLimit) {
//Special cases
if (upperLimit.compareTo(BigInteger.ZERO) == 0) {
return BigInteger.ZERO;
}
String upperLimit_String = upperLimit.toString();
int upperLimitStringLength = upperLimit_String.length();
Random[] random = a_Generic_Number.get_RandomArrayMinLength(
upperLimitStringLength);
if (upperLimit.compareTo(BigInteger.ONE) == 0) {
if (random[0].nextBoolean()) {
return BigInteger.ONE;
} else {
return BigInteger.ZERO;
}
}
int startIndex = 0;
int endIndex = 1;
String result_String = "";
int digit;
int upperLimitDigit;
int i;
//Take care not to assign any digit that will result in a number larger
//upperLimit
for (i = 0; i < upperLimitStringLength; i ++){
upperLimitDigit = new Integer(
upperLimit_String.substring(startIndex,endIndex));
startIndex ++;
endIndex ++;
digit = random[i].nextInt(upperLimitDigit + 1);
if (digit != upperLimitDigit){
break;
}
result_String += digit;
}
//Once something smaller than upperLimit guaranteed, assign any digit
//between zero and nine inclusive
for (i = i + 1; i < upperLimitStringLength; i ++) {
digit = random[i].nextInt(10);
result_String += digit;
}
//Tidy values starting with zero(s)
while (result_String.startsWith("0")) {
if (result_String.length() > 1) {
result_String = result_String.substring(1);
} else {
break;
}
}
BigInteger result = new BigInteger(result_String);
return result;
}

Compiler ce code F# dans une DLL et vous pouvez aussi y faire référence dans votre C# /VB.NET les programmes

type BigIntegerRandom() =
static let internalRandom = new Random()
///Returns a BigInteger random number of the specified number of bytes.
static member RandomBigInteger(numBytes:int, rand:Random) =
let r = if rand=null then internalRandom else rand
let bytes : byte[] = Array.zeroCreate (numBytes+1)
r.NextBytes(bytes)
bytes.[numBytes] <- 0uy
bigint bytes
///Returns a BigInteger random number from 0 (inclusive) to max (exclusive).
static member RandomBigInteger(max:bigint, rand:Random) =
let rec getNumBytesInRange num bytes = if max < num then bytes else getNumBytesInRange (num * 256I) bytes+1
let bytesNeeded = getNumBytesInRange 256I 1
BigIntegerRandom.RandomBigInteger(bytesNeeded, rand) % max
///Returns a BigInteger random number from min (inclusive) to max (exclusive).
static member RandomBigInteger(min:bigint, max:bigint, rand:Random) =
BigIntegerRandom.RandomBigInteger(max - min, rand) + min