Generator for arbitrarily large integral numbers

RandomBigInteger.java

/*
 * Copyright (c) 2020.
 *
 * Juergen Key. Alle Rechte vorbehalten.
 *
 * Weiterverbreitung und Verwendung in nichtkompilierter oder kompilierter Form,
 * mit oder ohne Veraenderung, sind unter den folgenden Bedingungen zulaessig:
 *
 *    1. Weiterverbreitete nichtkompilierte Exemplare muessen das obige Copyright,
 * die Liste der Bedingungen und den folgenden Haftungsausschluss im Quelltext
 * enthalten.
 *    2. Weiterverbreitete kompilierte Exemplare muessen das obige Copyright,
 * die Liste der Bedingungen und den folgenden Haftungsausschluss in der
 * Dokumentation und/oder anderen Materialien, die mit dem Exemplar verbreitet
 * werden, enthalten.
 *    3. Weder der Name des Autors noch die Namen der Beitragsleistenden
 * duerfen zum Kennzeichnen oder Bewerben von Produkten, die von dieser Software
 * abgeleitet wurden, ohne spezielle vorherige schriftliche Genehmigung verwendet
 * werden.
 *
 * DIESE SOFTWARE WIRD VOM AUTOR UND DEN BEITRAGSLEISTENDEN OHNE
 * JEGLICHE SPEZIELLE ODER IMPLIZIERTE GARANTIEN ZUR VERFUEGUNG GESTELLT, DIE
 * UNTER ANDEREM EINSCHLIESSEN: DIE IMPLIZIERTE GARANTIE DER VERWENDBARKEIT DER
 * SOFTWARE FUER EINEN BESTIMMTEN ZWECK. AUF KEINEN FALL IST DER AUTOR
 * ODER DIE BEITRAGSLEISTENDEN FUER IRGENDWELCHE DIREKTEN, INDIREKTEN,
 * ZUFAELLIGEN, SPEZIELLEN, BEISPIELHAFTEN ODER FOLGENDEN SCHAEDEN (UNTER ANDEREM
 * VERSCHAFFEN VON ERSATZGUETERN ODER -DIENSTLEISTUNGEN; EINSCHRAENKUNG DER
 * NUTZUNGSFAEHIGKEIT; VERLUST VON NUTZUNGSFAEHIGKEIT; DATEN; PROFIT ODER
 * GESCHAEFTSUNTERBRECHUNG), WIE AUCH IMMER VERURSACHT UND UNTER WELCHER
 * VERPFLICHTUNG AUCH IMMER, OB IN VERTRAG, STRIKTER VERPFLICHTUNG ODER
 * UNERLAUBTE HANDLUNG (INKLUSIVE FAHRLAESSIGKEIT) VERANTWORTLICH, AUF WELCHEM
 * WEG SIE AUCH IMMER DURCH DIE BENUTZUNG DIESER SOFTWARE ENTSTANDEN SIND, SOGAR,
 * WENN SIE AUF DIE MOEGLICHKEIT EINES SOLCHEN SCHADENS HINGEWIESEN WORDEN SIND.
 *
 */

package de.elbosso.algorithms.nr.rand;

public class RandomBigInteger
{
	private final static java.math.BigInteger FOUR=java.math.BigInteger.valueOf(4);
	private final java.util.Random rand;

	public RandomBigInteger() throws java.security.NoSuchAlgorithmException
	{
		this(java.security.SecureRandom.getInstance("SHA1PRNG"));
	}
	public RandomBigInteger(java.util.Random rand)
	{
		super();
		if(rand==null)
			throw new java.lang.IllegalArgumentException("rand must not be null!");
		this.rand = rand;
	}
	public java.math.BigInteger next(int bitLength)
	{
		return next(bitLength,false);
	}
	public java.math.BigInteger next(int bitLength,boolean signed)
	{
		if(bitLength<1)
			throw new java.lang.IllegalArgumentException("bitLength must be larger than 1!");
		boolean specialCase=false;
		if(bitLength%8==0)
		{
			specialCase=true;
			++bitLength;
		}
		int bitLengthinBytes=bitLength/8+((bitLength%8)>0?1:0);
		int bitMask=(bitLength%8);
//		System.out.println(bitLength+"\t"+bitLengthinBytes+"\t"+bitMask);
		byte mask=(byte)0xff;
//		System.out.println(Integer.toHexString(mask));
		mask=(byte)(mask<<(byte)bitMask);
//		System.out.println(Integer.toHexString(mask));
		mask=(byte)~mask;
//		System.out.println(Integer.toHexString(mask));
		int max=10;
		int counter=0;
		byte[] bytes=new byte[bitLengthinBytes];
		rand.nextBytes(bytes);
		bytes[0]&=mask;
		java.math.BigInteger one = new java.math.BigInteger(bytes);
		if(specialCase)
			one=one.divide(java.math.BigInteger.TWO);
		if(signed==true)
		{
			for (int i = 0; i < bitLengthinBytes; ++i)
			{
				bytes[i] = (byte) 0xff;
			}
			bytes[0] &= (byte) mask;
			java.math.BigInteger theBoss = new java.math.BigInteger(bytes);
			if (specialCase)
				theBoss = theBoss.divide(FOUR);
				//		System.out.println(theBoss);
			else
				theBoss = theBoss.divide(java.math.BigInteger.TWO);
			one=one.subtract(theBoss);
		}
		return one;
	}
}