Added initial implementation of Mersenne Twister

Author: TheJavaGuy

src/main/java/org/thejavaguy/prng/generators/MersenneTwister.java

@@ -1,6 +1,36 @@
 package org.thejavaguy.prng.generators;
 
 public class MersenneTwister implements PRNG {
+    private static final int N = 624;
+    private static final int M = 397;
+    private static final int INIT_MULTIPLICATOR = 1_812_433_253;
+    private static final int MATRIX_A = 0x9908b0df;
+    private static final int UPPER_MASK = 0x80000000;
+    private static final int LOWER_MASK = 0x7fffffff;
+    private static final int TEMPERING_MASK_B = 0x9d2c5680;
+    private static final int TEMPERING_MASK_C = 0xefc60000;
+    private static final int DEFAULT_SEED = 5489;
+    private int[] mt;
+    private int mti;
+    private int[] mag01;
+
+    public MersenneTwister() {
+        this(DEFAULT_SEED);
+    }
+
+    public MersenneTwister(int seed) {
+        if (seed == 0) {
+            throw new IllegalArgumentException("seed must not be 0");
+        }
+        mt = new int[N];
+        mt[0] = seed;
+        for (mti = 1; mti < N; ++mti) {
+            mt[mti] = (INIT_MULTIPLICATOR * (mt[mti-1] ^ (mt[mti-1] >>> 30)) + mti);
+        }
+        mag01 = new int[2];
+        mag01[0] = 0;
+        mag01[1] = MATRIX_A;
+    }
 
     @Override
     public double nextDouble() {
@@ -9,8 +39,27 @@ public double nextDouble() {
 
     @Override
     public int nextInt() {
-        // TODO Auto-generated method stub
-        return 0;
+        int ret = 0;
+        if (mti >= N) {
+            int kk = 0;
+            for (kk = 0; kk < N-M; ++kk) {
+                ret = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
+                mt[kk] = mt[kk+M] ^ (ret >>> 1) ^ mag01[ret & 0x1];
+            }
+            for (; kk < N-1; ++kk) {
+                ret = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
+                mt[kk] = mt[kk+(M-N)] ^ (ret >>> 1) ^ mag01[ret & 0x1];
+            }
+            ret = (mt[N-1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
+            mt[N-1] = mt[M-1] ^ (ret >>> 1) ^ mag01[ret & 0x1];
+            mti = 0;
+        }
+        ret = mt[mti++];
+        ret ^= (ret >>> 11);
+        ret ^= (ret << 7) & TEMPERING_MASK_B;
+        ret ^= (ret << 15) & TEMPERING_MASK_C;
+        ret ^= (ret >>> 18);
+        return ret;
     }
 
     @Override

src/main/java/org/thejavaguy/prng/generators/R250_521.java

@@ -28,7 +28,7 @@ public R250_521() {
     public R250_521(long seed) {
         r250_buffer = new int[NUM_ELEMENTS_250];
         r521_buffer = new int[NUM_ELEMENTS_521];
-        Random r = new Random();
+        Random r = new Random(seed);
         int i = NUM_ELEMENTS_521;
         while (i-- > 250) {
             r521_buffer[i] = r.nextInt();

src/test/java/org/thejavaguy/prng/generators/MersenneTwisterTest.java

@@ -0,0 +1,81 @@
+package org.thejavaguy.prng.generators;
+
+import static org.junit.Assert.*;
+import java.util.Set;
+import java.util.TreeSet;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class MersenneTwisterTest {
+    private MersenneTwister sut;
+
+    @Before
+    public void setUp() throws Exception {
+        sut = new MersenneTwister(645564);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        sut = null;
+    }
+
+    @Test
+    public void nextDouble_IsAlwaysGEQ0andL1() {
+        int reps = 10_000_000;
+        for (int i = 0; i < reps; ++i) {
+            double actual = sut.nextDouble();
+            assertTrue(actual >= 0);
+            assertTrue(actual < 1);
+        }
+    }
+
+    @Test
+    public void nextInt_WithUpperLimit_IsAlwaysWithinLimit() {
+        int reps = 10_000_000;
+        Set<Integer> results = new TreeSet<>();
+        for (int i = 0; i < reps; ++i) {
+            int actual = sut.nextInt(10);
+            results.add(actual);
+            assertTrue(actual >= 0);
+            assertTrue(actual <= 10);
+        }
+        assertEquals(11, results.size());
+    }
+
+    @Test
+    public void nextInt_WithUpperLimit_IsAlwaysWithinLimit2() {
+        int reps = 10_000_000;
+        for (int i = 0; i < reps; ++i) {
+            int actual = sut.nextInt(1);
+            assertTrue(actual >= 0);
+            assertTrue(actual <= 1);
+        }
+    }
+
+    @Test
+    public void nextInt_WithNegativeLimits_IsAlwaysWithinLimits() {
+        int reps = 10_000_000;
+        Set<Integer> results = new TreeSet<>();
+        for (int i = 0; i < reps; ++i) {
+            int actual = sut.nextInt(-10, -1);
+            results.add(Integer.valueOf(actual));
+            assertTrue(actual >= -10);
+            assertTrue(actual <= -1);
+        }
+        assertEquals(10, results.size());
+    }
+
+    @Test
+    public void nextByte_IsAlwaysWithinLimits() {
+        int reps = 10_000_000;
+        Set<Integer> results = new TreeSet<>();
+        for (int i = 0; i < reps; ++i) {
+            byte actual = sut.nextByte();
+            results.add(Integer.valueOf(actual));
+            assertTrue(actual >= -128);
+            assertTrue(actual <= 127);
+        }
+        assertEquals(256, results.size());
+    }
+}