more experimental random number generators

Author: TilmanNeumann

src/main/java/de/tilman_neumann/jml/base/Uint128.java

@@ -433,6 +433,32 @@ public static Uint128 mul128_getLow(Uint128 a, Uint128 b) { // derived from mul1
 		return r_lo;
 	}
 
+	/**
+	 * Get the lower 128 bit integer of a multiplication of two unsigned 128 bit integers, using Math.multiplyHigh().
+	 * 
+	 * @param a Uint128
+	 * @param b Uint128
+	 * @return the low Uint128 of a*b
+	 */
+	public static Uint128 mul128MH_getLow(Uint128 a, Uint128 b) { // derived from mul128_v2
+		final long a_hi = a.getHigh(); // a >>> 32;
+		final long b_hi = b.getHigh(); // b >>> 32;
+		final long a_lo = a.getLow(); // a & 0xFFFFFFFFL;
+		final long b_lo = b.getLow(); // b & 0xFFFFFFFFL;
+		
+		final Uint128 lo_prod = mul64_MH(a_lo, b_lo); // a_lo * b_lo;
+		final Uint128 med_prod1 = mul64_MH(a_hi, b_lo); // a_hi * b_lo;
+		final Uint128 med_prod2 = mul64_MH(a_lo, b_hi); // a_lo * b_hi;
+		final Uint128 med_term = med_prod1.add(med_prod2); // med_prod1 + med_prod2;
+		
+		//final long r_lo = ((med_term & 0xFFFFFFFFL) << 32) + lo_prod;
+		final long med_term_lo = med_term.getLow(); // (med_term & 0xFFFFFFFFL)
+		final Uint128 r_lo = new Uint128(med_term_lo, 0).add(lo_prod);
+		
+		//return new Uint128(r_hi, r_lo);
+		return r_lo;
+	}
+
 	/**
 	 * Compute quotient and remainder of this / v.
 	 * The quotient will be correct only if it is <= 64 bit.

src/main/java/de/tilman_neumann/jml/random/LehmerRng64.java

@@ -18,7 +18,7 @@
 /**
  * Lehmer's random number generator for 64 bit numbers; requires 128 bit multiplication internally.
  * 
- * This is class is still experimental. It seems to work but not much faster than Random yet.
+ * This is class is still <strong>experimental</strong>. It seems to work but not much faster than Random yet.
  * 
  * @see https://en.wikipedia.org/wiki/Lehmer_random_number_generator
  */

src/main/java/de/tilman_neumann/jml/random/LehmerRng64MH.java

@@ -0,0 +1,35 @@
+/*
+ * java-math-library is a Java library focused on number theory, but not necessarily limited to it. It is based on the PSIQS 4.0 factoring project.
+ * Copyright (C) 2018-2025 Tilman Neumann - tilman.neumann@web.de
+ *
+ * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program;
+ * if not, see <http://www.gnu.org/licenses/>.
+ */
+package de.tilman_neumann.jml.random;
+
+import de.tilman_neumann.jml.base.Uint128;
+
+/**
+ * Lehmer's random number generator for 64 bit numbers, using Math.multiplyHigh(); requires 128 bit multiplication internally.
+ * 
+ * This is class is still <strong>experimental</strong>.
+ * 
+ * @see https://en.wikipedia.org/wiki/Lehmer_random_number_generator
+ */
+public class LehmerRng64MH {
+	private static final Uint128 mult = new Uint128(0x12e15e35b500f16eL, 0x2e714eb2b37916a5L);
+
+	private Uint128 state = mult;
+	
+	public long nextLong() {
+		long result = state.getHigh();
+		state = Uint128.mul128MH_getLow(state, mult);
+		return result;
+	}
+}

src/main/java/de/tilman_neumann/jml/random/Xorshf32b.java

@@ -0,0 +1,48 @@
+/*
+ * java-math-library is a Java library focused on number theory, but not necessarily limited to it. It is based on the PSIQS 4.0 factoring project.
+ * Copyright (C) 2018-2025 Tilman Neumann - tilman.neumann@web.de
+ *
+ * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program;
+ * if not, see <http://www.gnu.org/licenses/>.
+ */
+package de.tilman_neumann.jml.random;
+
+/**
+ * An <strong>experimental</strong> variant of Marsaglia's xorshf generator.
+ * 
+ * @author Tilman Neumann
+ */
+public class Xorshf32b {
+	
+	private int x=123456789, y=362436069, z=521288629;
+
+	public int nextInt() {
+		int t;
+	    x ^= x << 16;
+	    x ^= x >> 5;
+	    x ^= x << 1;
+
+	    t = x;
+	    x = y;
+	    y = z;
+	    z = t ^ x ^ y;
+
+	    return z;
+	}
+	
+	public int nextInt(int max) {
+		final long l = nextInt();  // up to unsigned 2^32 - 1
+		final long prod = l * max; // up to max * (2^32 - 1)
+	    return (int) (prod >>> 32);
+	}
+	
+	public int nextInt(int min, int max) {
+	    return min + nextInt(max - min);
+	}
+}

src/main/java/de/tilman_neumann/jml/random/Xorshf64.java

@@ -0,0 +1,33 @@
+/*
+ * java-math-library is a Java library focused on number theory, but not necessarily limited to it. It is based on the PSIQS 4.0 factoring project.
+ * Copyright (C) 2018-2025 Tilman Neumann - tilman.neumann@web.de
+ *
+ * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program;
+ * if not, see <http://www.gnu.org/licenses/>.
+ */
+package de.tilman_neumann.jml.random;
+
+/**
+ * <strong>Experimental</strong> 64 bit random number generator computing longs from two consecutive 32 bit random numbers.
+ * 
+ * @author Tilman Neumann
+ */
+public class Xorshf64 {
+	
+	private Xorshf32 intGenerator = new Xorshf32();
+	
+	public long nextLong() {
+	    return ((long) intGenerator.nextInt()) * intGenerator.nextInt();
+	}
+	
+	// TODO nextLong(upper)
+	
+	// TODO nextLong(lower, upper)
+	
+}

src/test/java/de/tilman_neumann/jml/random/RngPerformanceTest.java

@@ -43,8 +43,11 @@ public class RngPerformanceTest {
 	private static final Rng rng = new Rng();
 	private static final SpRand32 spRand32 = new SpRand32();
 	private static final Xorshf32 xorshf32 = new Xorshf32();
+	private static final Xorshf32b xorshf32b = new Xorshf32b();
 	private static final LehmerRng64 lehmer64 = new LehmerRng64();
-	
+	private static final LehmerRng64MH lehmer64MH = new LehmerRng64MH();
+	private static final Xorshf64 xorshf64 = new Xorshf64();
+
 	/**
 	 * Test.
 	 * @param args ignored
@@ -76,6 +79,10 @@ public static void main(String[] args) {
 			xorshf32.nextInt();
 		}
 		LOG.debug("Xorshf32.nextInt() took " + timer.capture() + " ms");
+		for (int i=0; i<NCOUNT; i++) {
+			xorshf32b.nextInt();
+		}
+		LOG.debug("Xorshf32b.nextInt() took " + timer.capture() + " ms");
 
 		// test nextInt(int upper)
 		int upper = 1<<30 + 29;
@@ -101,6 +108,10 @@ public static void main(String[] args) {
 			xorshf32.nextInt(upper);
 		}
 		LOG.debug("Xorshf32.nextInt(upper) took " + timer.capture() + " ms");
+		for (int i=0; i<NCOUNT; i++) {
+			xorshf32b.nextInt(upper);
+		}
+		LOG.debug("Xorshf32b.nextInt(upper) took " + timer.capture() + " ms");
 
 		// test nextInt(int lower, int upper)
 		int lower = 12345;
@@ -128,6 +139,10 @@ public static void main(String[] args) {
 			xorshf32.nextInt(lower, upper);
 		}
 		LOG.debug("Xorshf32.nextInt(lower, upper) took " + timer.capture() + " ms");
+		for (int i=0; i<NCOUNT; i++) {
+			xorshf32b.nextInt(lower, upper);
+		}
+		LOG.debug("Xorshf32b.nextInt(lower, upper) took " + timer.capture() + " ms");
 
 		// test nextLong()
 		if (TEST_SLOW) {
@@ -148,5 +163,13 @@ public static void main(String[] args) {
 			lehmer64.nextLong();
 		}
 		LOG.debug("LehmerRng64.nextLong() took " + timer.capture() + " ms");
+		for (int i=0; i<NCOUNT; i++) {
+			lehmer64MH.nextLong();
+		}
+		LOG.debug("LehmerRng64MH.nextLong() took " + timer.capture() + " ms");
+		for (int i=0; i<NCOUNT; i++) {
+			xorshf64.nextLong();
+		}
+		LOG.debug("Xorshf64.nextLong() took " + timer.capture() + " ms");
 	}
 }