commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From er...@apache.org
Subject [35/53] [abbrv] [math] MATH-1335.
Date Thu, 21 Apr 2016 23:15:21 GMT
http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source32/MersenneTwister.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source32/MersenneTwister.java b/src/main/java/org/apache/commons/math4/rng/internal/source32/MersenneTwister.java
new file mode 100644
index 0000000..7ae5fd8
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source32/MersenneTwister.java
@@ -0,0 +1,230 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.source32;
+
+import java.util.Arrays;
+import org.apache.commons.math4.exception.InsufficientDataException;
+import org.apache.commons.math4.rng.internal.util.NumberFactory;
+
+/**
+ * This class implements a powerful pseudo-random number generator
+ * developed by Makoto Matsumoto and Takuji Nishimura during
+ * 1996-1997.
+ *
+ * <p>
+ * This generator features an extremely long period
+ * (2<sup>19937</sup>-1) and 623-dimensional equidistribution up to
+ * 32 bits accuracy.  The home page for this generator is located at
+ * <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html">
+ * http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html</a>.
+ * </p>
+ *
+ * <p>
+ * This generator is described in a paper by Makoto Matsumoto and
+ * Takuji Nishimura in 1998:
+ * <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/ARTICLES/mt.pdf">
+ * Mersenne Twister: A 623-Dimensionally Equidistributed Uniform Pseudo-Random
+ * Number Generator</a>,
+ * ACM Transactions on Modeling and Computer Simulation, Vol. 8, No. 1,
+ * January 1998, pp 3--30
+ * </p>
+ *
+ * <p>
+ * This class is mainly a Java port of the
+ * <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html">
+ * 2002-01-26 version of the generator</a> written in C by Makoto Matsumoto
+ * and Takuji Nishimura. Here is their original copyright:
+ * </p>
+ *
+ * <table border="0" width="80%" cellpadding="10" align="center" bgcolor="#E0E0E0">
+ * <tr><td>Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+ *     All rights reserved.</td></tr>
+ *
+ * <tr><td>Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * <ol>
+ *   <li>Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.</li>
+ *   <li>Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.</li>
+ *   <li>The names of its contributors may not be used to endorse or promote
+ *       products derived from this software without specific prior written
+ *       permission.</li>
+ * </ol></td></tr>
+ *
+ * <tr><td><strong>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.</strong></td></tr>
+ * </table>
+ *
+ * @since 4.0
+ */
+public class MersenneTwister extends IntProvider {
+    /** Mask 32 most significant bits. */
+    private static final long INT_MASK_LONG = 0xffffffffL;
+    /** Most significant w-r bits. */
+    private static final long UPPER_MASK_LONG = 0x80000000L;
+    /** Least significant r bits */
+    private static final long LOWER_MASK_LONG = 0x7fffffffL;
+    /** Most significant w-r bits. */
+    private static final int UPPER_MASK = 0x80000000;
+    /** Least significant r bits */
+    private static final int LOWER_MASK = 0x7fffffff;
+    /** Size of the bytes pool. */
+    private static final int N = 624;
+    /** Period second parameter. */
+    private static final int M = 397;
+    /** X * MATRIX_A for X = {0, 1}. */
+    private static final int[] MAG01 = { 0x0, 0x9908b0df };
+    /** Bytes pool. */
+    private int[] mt = new int[N];
+    /** Current index in the bytes pool. */
+    private int mti;
+
+    /**
+     * Creates a new random number generator.
+     *
+     * @param seed Initial seed.
+     */
+    public MersenneTwister(int[] seed) {
+        setSeedInternal(seed);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected byte[] getStateInternal() {
+        final int[] s = Arrays.copyOf(mt, N + 1);
+        s[N] = mti;
+
+        return NumberFactory.makeByteArray(s);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected void setStateInternal(byte[] s) {
+        if (s.length != (N + 1) * 4) {
+            throw new InsufficientDataException();
+        }
+
+        final int[] tmp = NumberFactory.makeIntArray(s);
+
+        System.arraycopy(tmp, 0, mt, 0, N);
+        mti = tmp[N];
+    }
+
+    /**
+     * Reinitializes the generator as if just built with the given seed.
+     *
+     * @param seed Initial seed.
+     */
+    private void setSeedInternal(int[] seed) {
+        initState(19650218);
+        int i = 1;
+        int j = 0;
+
+        for (int k = Math.max(N, seed.length); k != 0; k--) {
+            final long l0 = (mt[i] & LOWER_MASK_LONG)   | ((mt[i]   < 0) ? UPPER_MASK_LONG : 0);
+            final long l1 = (mt[i-1] & LOWER_MASK_LONG) | ((mt[i-1] < 0) ? UPPER_MASK_LONG : 0);
+            final long l  = (l0 ^ ((l1 ^ (l1 >> 30)) * 1664525l)) + seed[j] + j; // non linear
+            mt[i]   = (int) (l & INT_MASK_LONG);
+            i++; j++;
+            if (i >= N) {
+                mt[0] = mt[N - 1];
+                i = 1;
+            }
+            if (j >= seed.length) {
+                j = 0;
+            }
+        }
+
+        for (int k = N - 1; k != 0; k--) {
+            final long l0 = (mt[i] & LOWER_MASK_LONG)   | ((mt[i]   < 0) ? UPPER_MASK_LONG : 0);
+            final long l1 = (mt[i-1] & LOWER_MASK_LONG) | ((mt[i-1] < 0) ? UPPER_MASK_LONG : 0);
+            final long l  = (l0 ^ ((l1 ^ (l1 >> 30)) * 1566083941l)) - i; // non linear
+            mt[i]   = (int) (l & INT_MASK_LONG);
+            i++;
+            if (i >= N) {
+                mt[0] = mt[N - 1];
+                i = 1;
+            }
+        }
+
+        mt[0] = UPPER_MASK; // MSB is 1; assuring non-zero initial array
+    }
+
+    /**
+     * Initialize the internal state of this instance.
+     *
+     * @param seed Seed.
+     */
+    private void initState(int seed) {
+        long longMT = seed & INT_MASK_LONG;
+        mt[0]= (int) longMT;
+        for (mti = 1; mti < N; ++mti) {
+            longMT = (1812433253L * (longMT ^ (longMT >> 30)) + mti) & INT_MASK_LONG;
+            mt[mti]= (int) longMT;
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int next() {
+        int y;
+
+        if (mti >= N) { // Generate N words at one time.
+            int mtNext = mt[0];
+            for (int k = 0; k < N - M; ++k) {
+                int mtCurr = mtNext;
+                mtNext = mt[k + 1];
+                y = (mtCurr & UPPER_MASK) | (mtNext & LOWER_MASK);
+                mt[k] = mt[k + M] ^ (y >>> 1) ^ MAG01[y & 1];
+            }
+            for (int k = N - M; k < N - 1; ++k) {
+                int mtCurr = mtNext;
+                mtNext = mt[k + 1];
+                y = (mtCurr & UPPER_MASK) | (mtNext & LOWER_MASK);
+                mt[k] = mt[k + (M - N)] ^ (y >>> 1) ^ MAG01[y & 1];
+            }
+            y = (mtNext & UPPER_MASK) | (mt[0] & LOWER_MASK);
+            mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ MAG01[y & 1];
+
+            mti = 0;
+        }
+
+        y = mt[mti++];
+
+        // Tempering.
+        y ^=  y >>> 11;
+        y ^= (y << 7) & 0x9d2c5680;
+        y ^= (y << 15) & 0xefc60000;
+        y ^=  y >>> 18;
+
+        return y;
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source32/RandomIntSource.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source32/RandomIntSource.java b/src/main/java/org/apache/commons/math4/rng/internal/source32/RandomIntSource.java
new file mode 100644
index 0000000..88f420c
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source32/RandomIntSource.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.math4.rng.internal.source32;
+
+/**
+ * Source of randomness that generate values of type {@code int}.
+ *
+ * @since 4.0
+ */
+public interface RandomIntSource {
+    /**
+     * @return the next random value.
+     */
+    int next();
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source32/Well1024a.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source32/Well1024a.java b/src/main/java/org/apache/commons/math4/rng/internal/source32/Well1024a.java
new file mode 100644
index 0000000..86c84c3
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source32/Well1024a.java
@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.source32;
+
+/**
+ * This class implements the WELL1024a pseudo-random number generator
+ * from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto Matsumoto.
+ * <p>
+ * This generator is described in a paper by Fran&ccedil;ois Panneton,
+ * Pierre L'Ecuyer and Makoto Matsumoto
+ * <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
+ * Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
+ * ACM Transactions on Mathematical Software, 32, 1 (2006).
+ * The errata for the paper are in
+ * <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
+ * </p>
+ *
+ * @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
+ * @since 4.0
+ */
+public class Well1024a extends AbstractWell {
+    /** Number of bits in the pool. */
+    private static final int K = 1024;
+    /** First parameter of the algorithm. */
+    private static final int M1 = 3;
+    /** Second parameter of the algorithm. */
+    private static final int M2 = 24;
+    /** Third parameter of the algorithm. */
+    private static final int M3 = 10;
+    /** The indirection index table. */
+    private static final IndexTable TABLE = new IndexTable(K, M1, M2, M3);
+
+    /**
+     * Creates a new random number generator.
+     *
+     * @param seed Initial seed.
+     */
+    public Well1024a(int[] seed) {
+        super(K, seed);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int next() {
+        final int indexRm1 = TABLE.getIndexPred(index);
+
+        final int v0 = v[index];
+        final int vM1 = v[TABLE.getIndexM1(index)];
+        final int vM2 = v[TABLE.getIndexM2(index)];
+        final int vM3 = v[TABLE.getIndexM3(index)];
+
+        final int z0 = v[indexRm1];
+        final int z1 = v0 ^ (vM1 ^ (vM1 >>> 8));
+        final int z2 = (vM2 ^ (vM2 << 19)) ^ (vM3 ^ (vM3 << 14));
+        final int z3 = z1 ^ z2;
+        final int z4 = (z0 ^ (z0 << 11)) ^ (z1 ^ (z1 << 7)) ^ (z2 ^ (z2 << 13));
+
+        v[index] = z3;
+        v[indexRm1] = z4;
+        index = indexRm1;
+
+        return z4;
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source32/Well19937a.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source32/Well19937a.java b/src/main/java/org/apache/commons/math4/rng/internal/source32/Well19937a.java
new file mode 100644
index 0000000..7f83ddf
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source32/Well19937a.java
@@ -0,0 +1,80 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.source32;
+
+/**
+ * This class implements the WELL19937a pseudo-random number generator
+ * from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto Matsumoto.
+ * <p>
+ * This generator is described in a paper by Fran&ccedil;ois Panneton,
+ * Pierre L'Ecuyer and Makoto Matsumoto
+ * <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
+ * Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
+ * ACM Transactions on Mathematical Software, 32, 1 (2006).
+ * The errata for the paper are in
+ * <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
+ * </p>
+ *
+ * @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
+ * @since 4.0
+ */
+public class Well19937a extends AbstractWell {
+    /** Number of bits in the pool. */
+    private static final int K = 19937;
+    /** First parameter of the algorithm. */
+    private static final int M1 = 70;
+    /** Second parameter of the algorithm. */
+    private static final int M2 = 179;
+    /** Third parameter of the algorithm. */
+    private static final int M3 = 449;
+    /** The indirection index table. */
+    private static final IndexTable TABLE = new IndexTable(K, M1, M2, M3);
+
+    /**
+     * Creates a new random number generator.
+     *
+     * @param seed Initial seed.
+     */
+    public Well19937a(int[] seed) {
+        super(K, seed);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int next() {
+        final int indexRm1 = TABLE.getIndexPred(index);
+        final int indexRm2 = TABLE.getIndexPred2(index);
+
+        final int v0 = v[index];
+        final int vM1 = v[TABLE.getIndexM1(index)];
+        final int vM2 = v[TABLE.getIndexM2(index)];
+        final int vM3 = v[TABLE.getIndexM3(index)];
+
+        final int z0 = (0x80000000 & v[indexRm1]) ^ (0x7FFFFFFF & v[indexRm2]);
+        final int z1 = (v0 ^ (v0 << 25)) ^ (vM1 ^ (vM1 >>> 27));
+        final int z2 = (vM2 >>> 9) ^ (vM3 ^ (vM3 >>> 1));
+        final int z3 = z1 ^ z2;
+        final int z4 = z0 ^ (z1 ^ (z1 << 9)) ^ (z2 ^ (z2 << 21)) ^ (z3 ^ (z3 >>> 21));
+
+        v[index] = z3;
+        v[indexRm1] = z4;
+        v[indexRm2] &= 0x80000000;
+        index = indexRm1;
+
+        return z4;
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source32/Well19937c.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source32/Well19937c.java b/src/main/java/org/apache/commons/math4/rng/internal/source32/Well19937c.java
new file mode 100644
index 0000000..25b9d03
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source32/Well19937c.java
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.source32;
+
+/**
+ * This class implements the WELL19937c pseudo-random number generator
+ * from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto Matsumoto.
+ * <p>
+ * This generator is described in a paper by Fran&ccedil;ois Panneton,
+ * Pierre L'Ecuyer and Makoto Matsumoto
+ * <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
+ * Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
+ * ACM Transactions on Mathematical Software, 32, 1 (2006).
+ * The errata for the paper are in
+ * <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
+ * </p>
+ *
+ * @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
+ * @since 2.2
+ */
+public class Well19937c extends AbstractWell {
+    /** Number of bits in the pool. */
+    private static final int K = 19937;
+    /** First parameter of the algorithm. */
+    private static final int M1 = 70;
+    /** Second parameter of the algorithm. */
+    private static final int M2 = 179;
+    /** Third parameter of the algorithm. */
+    private static final int M3 = 449;
+    /** The indirection index table. */
+    private static final IndexTable TABLE = new IndexTable(K, M1, M2, M3);
+
+    /**
+     * Creates a new random number generator.
+     *
+     * @param seed Initial seed.
+     */
+    public Well19937c(int[] seed) {
+        super(K, seed);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int next() {
+        final int indexRm1 = TABLE.getIndexPred(index);
+        final int indexRm2 = TABLE.getIndexPred2(index);
+
+        final int v0 = v[index];
+        final int vM1 = v[TABLE.getIndexM1(index)];
+        final int vM2 = v[TABLE.getIndexM2(index)];
+        final int vM3 = v[TABLE.getIndexM3(index)];
+
+        final int z0 = (0x80000000 & v[indexRm1]) ^ (0x7FFFFFFF & v[indexRm2]);
+        final int z1 = (v0 ^ (v0 << 25)) ^ (vM1 ^ (vM1 >>> 27));
+        final int z2 = (vM2 >>> 9) ^ (vM3 ^ (vM3 >>> 1));
+        final int z3 = z1 ^ z2;
+        int z4 = z0 ^ (z1 ^ (z1 << 9)) ^ (z2 ^ (z2 << 21)) ^ (z3 ^ (z3 >>> 21));
+
+        v[index] = z3;
+        v[indexRm1] = z4;
+        v[indexRm2] &= 0x80000000;
+        index = indexRm1;
+
+        // add Matsumoto-Kurita tempering
+        // to get a maximally-equidistributed generator
+        z4 ^= (z4 <<  7) & 0xe46e1700;
+        z4 ^= (z4 << 15) & 0x9b868000;
+
+        return z4;
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source32/Well44497a.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source32/Well44497a.java b/src/main/java/org/apache/commons/math4/rng/internal/source32/Well44497a.java
new file mode 100644
index 0000000..8b72b83
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source32/Well44497a.java
@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.source32;
+
+/**
+ * This class implements the WELL44497a pseudo-random number generator
+ * from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto Matsumoto.
+ * <p>
+ * This generator is described in a paper by Fran&ccedil;ois Panneton,
+ * Pierre L'Ecuyer and Makoto Matsumoto
+ * <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
+ * Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
+ * ACM Transactions on Mathematical Software, 32, 1 (2006).
+ * The errata for the paper are in
+ * <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
+ * </p>
+ *
+ * @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
+ * @since 4.0
+ */
+public class Well44497a extends AbstractWell {
+    /** Number of bits in the pool. */
+    private static final int K = 44497;
+    /** First parameter of the algorithm. */
+    private static final int M1 = 23;
+    /** Second parameter of the algorithm. */
+    private static final int M2 = 481;
+    /** Third parameter of the algorithm. */
+    private static final int M3 = 229;
+    /** The indirection index table. */
+    private static final IndexTable TABLE = new IndexTable(K, M1, M2, M3);
+
+    /**
+     * Creates a new random number generator.
+     *
+     * @param seed Initial seed.
+     */
+    public Well44497a(int[] seed) {
+        super(K, seed);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int next() {
+        final int indexRm1 = TABLE.getIndexPred(index);
+        final int indexRm2 = TABLE.getIndexPred2(index);
+
+        final int v0 = v[index];
+        final int vM1 = v[TABLE.getIndexM1(index)];
+        final int vM2 = v[TABLE.getIndexM2(index)];
+        final int vM3 = v[TABLE.getIndexM3(index)];
+
+        // the values below include the errata of the original article
+        final int z0 = (0xFFFF8000 & v[indexRm1]) ^ (0x00007FFF & v[indexRm2]);
+        final int z1 = (v0 ^ (v0 << 24)) ^ (vM1 ^ (vM1 >>> 30));
+        final int z2 = (vM2 ^ (vM2 << 10)) ^ (vM3 << 26);
+        final int z3 = z1 ^ z2;
+        final int z2Prime  = ((z2 << 9) ^ (z2 >>> 23)) & 0xfbffffff;
+        final int z2Second = ((z2 & 0x00020000) != 0) ? (z2Prime ^ 0xb729fcec) : z2Prime;
+        final int z4 = z0 ^ (z1 ^ (z1 >>> 20)) ^ z2Second ^ z3;
+
+        v[index] = z3;
+        v[indexRm1] = z4;
+        v[indexRm2] &= 0xFFFF8000;
+        index = indexRm1;
+
+        return z4;
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source32/Well44497b.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source32/Well44497b.java b/src/main/java/org/apache/commons/math4/rng/internal/source32/Well44497b.java
new file mode 100644
index 0000000..5300aba
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source32/Well44497b.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.source32;
+
+/**
+ * This class implements the WELL44497b pseudo-random number generator
+ * from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto Matsumoto.
+ * <p>
+ * This generator is described in a paper by Fran&ccedil;ois Panneton,
+ * Pierre L'Ecuyer and Makoto Matsumoto
+ * <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
+ * Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
+ * ACM Transactions on Mathematical Software, 32, 1 (2006).
+ * The errata for the paper are in
+ * <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
+ * </p>
+ *
+ * @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
+ * @since 4.0
+ */
+public class Well44497b extends AbstractWell {
+    /** Number of bits in the pool. */
+    private static final int K = 44497;
+    /** First parameter of the algorithm. */
+    private static final int M1 = 23;
+    /** Second parameter of the algorithm. */
+    private static final int M2 = 481;
+    /** Third parameter of the algorithm. */
+    private static final int M3 = 229;
+    /** The indirection index table. */
+    private static final IndexTable TABLE = new IndexTable(K, M1, M2, M3);
+
+    /**
+     * Creates a new random number generator.
+     *
+     * @param seed Initial seed.
+     */
+    public Well44497b(int[] seed) {
+        super(K, seed);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int next() {
+        // compute raw value given by WELL44497a generator
+        // which is NOT maximally-equidistributed
+        final int indexRm1 = TABLE.getIndexPred(index);
+        final int indexRm2 = TABLE.getIndexPred2(index);
+
+        final int v0 = v[index];
+        final int vM1 = v[TABLE.getIndexM1(index)];
+        final int vM2 = v[TABLE.getIndexM2(index)];
+        final int vM3 = v[TABLE.getIndexM3(index)];
+
+        // the values below include the errata of the original article
+        final int z0 = (0xFFFF8000 & v[indexRm1]) ^ (0x00007FFF & v[indexRm2]);
+        final int z1 = (v0 ^ (v0 << 24))  ^ (vM1 ^ (vM1 >>> 30));
+        final int z2 = (vM2 ^ (vM2 << 10)) ^ (vM3 << 26);
+        final int z3 = z1 ^ z2;
+        final int z2Prime = ((z2 << 9) ^ (z2 >>> 23)) & 0xfbffffff;
+        final int z2Second = ((z2 & 0x00020000) != 0) ? (z2Prime ^ 0xb729fcec) : z2Prime;
+        int z4 = z0 ^ (z1 ^ (z1 >>> 20)) ^ z2Second ^ z3;
+
+        v[index] = z3;
+        v[indexRm1] = z4;
+        v[indexRm2] &= 0xFFFF8000;
+        index = indexRm1;
+
+        // add Matsumoto-Kurita tempering
+        // to get a maximally-equidistributed generator
+        z4 ^= (z4 <<  7) & 0x93dd1400;
+        z4 ^= (z4 << 15) & 0xfa118000;
+
+        return z4;
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source32/Well512a.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source32/Well512a.java b/src/main/java/org/apache/commons/math4/rng/internal/source32/Well512a.java
new file mode 100644
index 0000000..1faf571
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source32/Well512a.java
@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.source32;
+
+/**
+ * This class implements the WELL512a pseudo-random number generator
+ * from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto Matsumoto.
+ * <p>
+ * This generator is described in a paper by Fran&ccedil;ois Panneton,
+ * Pierre L'Ecuyer and Makoto Matsumoto
+ * <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
+ * Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
+ * ACM Transactions on Mathematical Software, 32, 1 (2006).
+ * The errata for the paper are in
+ * <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
+ * </p>
+ *
+ * @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
+ * @since 4.0
+ */
+public class Well512a extends AbstractWell {
+    /** Number of bits in the pool. */
+    private static final int K = 512;
+    /** First parameter of the algorithm. */
+    private static final int M1 = 13;
+    /** Second parameter of the algorithm. */
+    private static final int M2 = 9;
+    /** Third parameter of the algorithm. */
+    private static final int M3 = 5;
+    /** The indirection index table. */
+    private static final IndexTable TABLE = new IndexTable(K, M1, M2, M3);
+
+    /**
+     * Creates a new random number generator.
+     *
+     * @param seed Initial seed.
+     */
+    public Well512a(int[] seed) {
+        super(K, seed);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int next() {
+        final int indexRm1 = TABLE.getIndexPred(index);
+
+        final int vi = v[index];
+        final int vi1 = v[TABLE.getIndexM1(index)];
+        final int vi2 = v[TABLE.getIndexM2(index)];
+        final int z0 = v[indexRm1];
+
+        // the values below include the errata of the original article
+        final int z1 = (vi ^ (vi << 16)) ^ (vi1 ^ (vi1 << 15));
+        final int z2 = vi2 ^ (vi2 >>> 11);
+        final int z3 = z1 ^ z2;
+        final int z4 = (z0 ^ (z0 << 2)) ^ (z1 ^ (z1 << 18)) ^ (z2 << 28) ^ (z3 ^ ((z3 << 5) & 0xda442d24));
+
+        v[index] = z3;
+        v[indexRm1] = z4;
+        index = indexRm1;
+
+        return z4;
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source32/package-info.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source32/package-info.java b/src/main/java/org/apache/commons/math4/rng/internal/source32/package-info.java
new file mode 100644
index 0000000..bb7d2e2
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source32/package-info.java
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * <h3>
+ * Concrete algorithms for {@code int}-based sources of randomness
+ * </h3>
+ *
+ * <p>
+ * <b>For internal use only:</b> Direct access to classes in this package
+ * is discouraged, as they could be modified without notice.
+ * </p>
+ *
+ * <p><b>Notes for developers</b></p>
+ *
+ * <ul>
+ *  <li>
+ *   A source of randomness must inherit from
+ *   {@link org.apache.commons.math4.rng.internal.source32.IntProvider}
+ *  </li>
+ *  <li>
+ *   The "provider" must specify <em>one</em> way for setting the seed.
+ *   For a given seed, the generated sequence must always be the same.
+ *  </li>
+ *  <li>
+ *   The "provider" must implement methods {@code getStateInternal} and
+ *   {@code setStateInternal} in order to save and restore the state of an
+ *   instance (cf. {@link org.apache.commons.math4.rng.internal.BaseProvider}).
+ *  </li>
+ *  <li>
+ *   When a new class is implemented here, user-access to it must be provided
+ *   through associated {@link org.apache.commons.math4.rng.RandomSource
+ *   factory methods}.
+ *  </li>
+ * </ul>
+ */
+
+package org.apache.commons.math4.rng.internal.source32;

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source64/LongProvider.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source64/LongProvider.java b/src/main/java/org/apache/commons/math4/rng/internal/source64/LongProvider.java
new file mode 100644
index 0000000..3e73f05
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source64/LongProvider.java
@@ -0,0 +1,141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.math4.rng.internal.source64;
+
+import org.apache.commons.math4.exception.OutOfRangeException;
+import org.apache.commons.math4.rng.internal.util.NumberFactory;
+import org.apache.commons.math4.rng.internal.BaseProvider;
+
+/**
+ * Base class for all implementations that provide a {@code long}-based
+ * source randomness.
+ */
+public abstract class LongProvider
+    extends BaseProvider
+    implements RandomLongSource {
+
+    /** {@inheritDoc} */
+    @Override
+    public abstract long next();
+
+    /** {@inheritDoc} */
+    @Override
+    public long nextLong() {
+        return next();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int nextInt() {
+        return NumberFactory.makeInt(nextLong());
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public double nextDouble() {
+        return NumberFactory.makeDouble(nextLong());
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean nextBoolean() {
+        return NumberFactory.makeBoolean(nextLong());
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public float nextFloat() {
+        return NumberFactory.makeFloat(nextInt());
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void nextBytes(byte[] bytes) {
+        nextBytesFill(this, bytes, 0, bytes.length);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void nextBytes(byte[] bytes,
+                          int start,
+                          int len) {
+        if (start < 0 ||
+            start >= bytes.length) {
+            throw new OutOfRangeException(start, 0, bytes.length);
+        }
+        if (len < 0 ||
+            len > bytes.length - start) {
+            throw new OutOfRangeException(len, 0, bytes.length - start);
+        }
+
+        nextBytesFill(this, bytes, start, len);
+    }
+
+    /**
+     * Generates random bytes and places them into a user-supplied array.
+     *
+     * <p>
+     * The array is filled with bytes extracted from random {@code long} values.
+     * This implies that the number of random bytes generated may be larger than
+     * the length of the byte array.
+     * </p>
+     *
+     * @param source Source of randomness.
+     * @param bytes Array in which to put the generated bytes. Cannot be null.
+     * @param start Index at which to start inserting the generated bytes.
+     * @param len Number of bytes to insert.
+     */
+    static void nextBytesFill(RandomLongSource source,
+                              byte[] bytes,
+                              int start,
+                              int len) {
+        int index = start; // Index of first insertion.
+
+        // Index of first insertion plus multiple of 8 part of length
+        // (i.e. length with 3 least significant bits unset).
+        final int indexLoopLimit = index + (len & 0x7ffffff8);
+
+        // Start filling in the byte array, 8 bytes at a time.
+        while (index < indexLoopLimit) {
+            final long random = source.next();
+            bytes[index++] = (byte) random;
+            bytes[index++] = (byte) (random >>> 8);
+            bytes[index++] = (byte) (random >>> 16);
+            bytes[index++] = (byte) (random >>> 24);
+            bytes[index++] = (byte) (random >>> 32);
+            bytes[index++] = (byte) (random >>> 40);
+            bytes[index++] = (byte) (random >>> 48);
+            bytes[index++] = (byte) (random >>> 56);
+        }
+
+        final int indexLimit = start + len; // Index of last insertion + 1.
+
+        // Fill in the remaining bytes.
+        if (index < indexLimit) {
+            long random = source.next();
+            while (true) {
+                bytes[index++] = (byte) random;
+                if (index < indexLimit) {
+                    random >>>= 8;
+                } else {
+                    break;
+                }
+            }
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source64/MersenneTwister64.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source64/MersenneTwister64.java b/src/main/java/org/apache/commons/math4/rng/internal/source64/MersenneTwister64.java
new file mode 100644
index 0000000..0280842
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source64/MersenneTwister64.java
@@ -0,0 +1,201 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.source64;
+
+import java.util.Arrays;
+import org.apache.commons.math4.exception.InsufficientDataException;
+import org.apache.commons.math4.rng.internal.util.NumberFactory;
+
+/**
+ * This class provides the 64-bits version of the originally 32-bits
+ * {@link org.apache.commons.math4.rng.internal.source32.MersenneTwister
+ * Mersenne Twister}.
+ *
+ * <p>
+ * This class is mainly a Java port of
+ * <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt64.html">
+ *  the 2014/2/23 version of the generator
+ * </a> written in C by Takuji Nishimura and Makoto Matsumoto.
+ * </p>
+ *
+ * <p>
+ * Here is their original copyright:
+ * </p>
+ *
+ * <table border="0" width="80%" cellpadding="10" align="center" bgcolor="#E0E0E0">
+ * <tr><td>Copyright (C) 2004, Makoto Matsumoto and Takuji Nishimura,
+ *     All rights reserved.</td></tr>
+ *
+ * <tr><td>Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * <ol>
+ *   <li>Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.</li>
+ *   <li>Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.</li>
+ *   <li>The names of its contributors may not be used to endorse or promote
+ *       products derived from this software without specific prior written
+ *       permission.</li>
+ * </ol></td></tr>
+ *
+ * <tr><td><strong>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.</strong></td></tr>
+ * </table>
+ *
+ * @since 4.0
+ */
+public class MersenneTwister64 extends LongProvider {
+    /** Size of the bytes pool. */
+    private static final int NN = 312;
+    /** Period second parameter. */
+    private static final int MM = 156;
+    /** X * MATRIX_A for X = {0, 1}. */
+    private static final long[] MAG01 = { 0x0, 0xb5026f5aa96619e9L };
+    /** Most significant 33 bits. */
+    private static final long UM = 0xffffffff80000000L;
+    /** Least significant 31 bits. */
+    private static final long LM = 0x7fffffffL;
+    /** Bytes pool. */
+    private long[] mt = new long[NN];
+    /** Current index in the bytes pool. */
+    private int mti;
+
+    /**
+     * Creates a new random number generator.
+     *
+     * @param seed Initial seed.
+     */
+    public MersenneTwister64(long[] seed) {
+        setSeedInternal(seed);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected byte[] getStateInternal() {
+        final long[] s = Arrays.copyOf(mt, NN + 1);
+        s[NN] = mti;
+
+        return NumberFactory.makeByteArray(s);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected void setStateInternal(byte[] s) {
+        if (s.length != (NN + 1) * 8) {
+            throw new InsufficientDataException();
+        }
+
+        final long[] tmp = NumberFactory.makeLongArray(s);
+
+        System.arraycopy(tmp, 0, mt, 0, NN);
+        mti = (int) tmp[NN];
+    }
+
+    /**
+     * Reinitializes the generator as if just built with the given seed.
+     *
+     * @param seed Initial seed.
+     */
+    private void setSeedInternal(long[] seed) {
+        initState(19650218L);
+
+        int i = 1;
+        int j = 0;
+
+        for (int k = Math.max(NN, seed.length); k != 0; k--) {
+            final long mm1 = mt[i - 1];
+            mt[i] = (mt[i] ^ ((mm1 ^ (mm1 >>> 62)) * 0x369dea0f31a53f85L)) + seed[j] + j; // non linear
+            i++;
+            j++;
+            if (i >= NN) {
+                mt[0] = mt[NN - 1];
+                i = 1;
+            }
+            if (j >= seed.length) {
+                j = 0;
+            }
+        }
+        for (int k = NN - 1; k != 0; k--) {
+            final long mm1 = mt[i - 1];
+            mt[i] = (mt[i] ^ ((mm1 ^ (mm1 >>> 62)) * 0x27bb2ee687b0b0fdL)) - i; // non linear
+            i++;
+            if (i >= NN) {
+                mt[0] = mt[NN - 1];
+                i = 1;
+            }
+        }
+
+        mt[0] = 0x8000000000000000L; // MSB is 1; assuring non-zero initial array
+    }
+
+    /**
+     * Initialize the internal state of this instance.
+     *
+     * @param seed Seed.
+     */
+    private void initState(long seed) {
+        mt[0] = seed;
+        for (mti = 1; mti < NN; mti++) {
+            final long mm1 = mt[mti - 1];
+            mt[mti] = 0x5851f42d4c957f2dL * (mm1 ^ (mm1 >>> 62)) + mti;
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public long next() {
+        long x;
+
+        if (mti >= NN) { // generate NN words at one time
+            for (int i = 0; i < NN - MM; i++) {
+                x = (mt[i] & UM) | (mt[i + 1] & LM);
+                mt[i] = mt[i + MM] ^ (x >>> 1) ^ MAG01[(int)(x & 0x1L)];
+            }
+            for (int i = NN - MM; i < NN - 1; i++) {
+                x = (mt[i] & UM) | (mt[i + 1] & LM);
+                mt[i] = mt[ i + (MM - NN)] ^ (x >>> 1) ^ MAG01[(int)(x & 0x1L)];
+            }
+
+            x = (mt[NN - 1] & UM) | (mt[0] & LM);
+            mt[NN - 1] = mt[MM - 1] ^ (x >>> 1) ^ MAG01[(int)(x & 0x1L)];
+
+            mti = 0;
+        }
+
+        x = mt[mti++];
+
+        x ^= (x >>> 29) & 0x5555555555555555L;
+        x ^= (x << 17) & 0x71d67fffeda60000L;
+        x ^= (x << 37) & 0xfff7eee000000000L;
+        x ^= x >>> 43;
+
+        return x;
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source64/RandomLongSource.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source64/RandomLongSource.java b/src/main/java/org/apache/commons/math4/rng/internal/source64/RandomLongSource.java
new file mode 100644
index 0000000..0daa068
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source64/RandomLongSource.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.math4.rng.internal.source64;
+
+/**
+ * Source of randomness that generate values of type {@code long}.
+ *
+ * @since 4.0
+ */
+public interface RandomLongSource {
+    /**
+     * @return the next random value.
+     */
+    long next();
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source64/SplitMix64.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source64/SplitMix64.java b/src/main/java/org/apache/commons/math4/rng/internal/source64/SplitMix64.java
new file mode 100644
index 0000000..086bd03
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source64/SplitMix64.java
@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.math4.rng.internal.source64;
+
+import org.apache.commons.math4.exception.InsufficientDataException;
+import org.apache.commons.math4.rng.internal.util.NumberFactory;
+
+/**
+ * A fast RNG, with 64 bits of state, that can be used to initialize the
+ * state of other generators.
+ *
+ * @see <a href="http://xorshift.di.unimi.it/splitmix64.c">
+ * Original source code</a>
+ *
+ * @since 4.0
+ */
+public class SplitMix64 extends LongProvider {
+    /** State. */
+    private long state;
+
+    /**
+     * Creates a new instance.
+     *
+     * @param seed Initial seed.
+     */
+    public SplitMix64(Long seed) {
+        setSeedInternal(seed);
+    }
+
+    /**
+     * Seeds the RNG.
+     *
+     * @param seed Seed.
+     */
+    private void setSeedInternal(Long seed) {
+        state = seed;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public long next() {
+        long z = state += 0x9e3779b97f4a7c15L;
+        z = (z ^ (z >>> 30)) * 0xbf58476d1ce4e5b9L;
+        z = (z ^ (z >>> 27)) * 0x94d049bb133111ebL;
+        return z ^ (z >>> 31);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected byte[] getStateInternal() {
+        return NumberFactory.makeByteArray(state);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected void setStateInternal(byte[] s) {
+        if (s.length != 8) {
+            throw new InsufficientDataException();
+        }
+
+        state = NumberFactory.makeLong(s);
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source64/TwoCmres.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source64/TwoCmres.java b/src/main/java/org/apache/commons/math4/rng/internal/source64/TwoCmres.java
new file mode 100644
index 0000000..d6fdcd6
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source64/TwoCmres.java
@@ -0,0 +1,310 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.math4.rng.internal.source64;
+
+import java.util.List;
+import java.util.ArrayList;
+import org.apache.commons.math4.exception.MathInternalError;
+import org.apache.commons.math4.exception.OutOfRangeException;
+import org.apache.commons.math4.exception.InsufficientDataException;
+import org.apache.commons.math4.rng.internal.util.NumberFactory;
+
+/**
+ * Random number generator designed by Mark D. Overton.
+ * <p>
+ *  It is one of the many generators described by the author in the following article series:
+ *  <ul>
+ *   <li><a href="http://www.drdobbs.com/tools/fast-high-quality-parallel-random-number/229625477">Part one</a></li>
+ *   <li><a href="http://www.drdobbs.com/tools/fast-high-quality-parallel-random-number/231000484">Part two</a></li>
+ *  </ul>
+ * </p>
+ *
+ * @since 4.0
+ */
+public class TwoCmres extends LongProvider {
+    /** A small positive integer. */
+    private static final byte SEED_GUARD = 9;
+    /** Factory of instances of this class. Singleton. */
+    private static final Cmres.Factory FACTORY = new Cmres.Factory();
+    /** First subcycle generator. */
+    private final Cmres x;
+    /** Second subcycle generator. */
+    private final Cmres y;
+    /** State of first subcycle generator. */
+    private long xx;
+    /** State of second subcycle generator. */
+    private long yy;
+
+    /**
+     * Creates a new instance.
+     *
+     * @param seed Initial seed.
+     * @param x First subcycle generator.
+     * @param y Second subcycle generator.
+     * @throws InsufficientDataException if {@code x == y}.
+     */
+    private TwoCmres(int seed,
+                     Cmres x,
+                     Cmres y) {
+        if (x == y) {
+            throw new InsufficientDataException();
+        }
+        this.x = x;
+        this.y = y;
+        setSeedInternal(seed);
+    }
+
+    /**
+     * Creates a new instance.
+     *
+     * @param seed Seed.
+     */
+    public TwoCmres(Integer seed) {
+        this(seed, 0, 1);
+    }
+
+    /**
+     * Creates a new instance.
+     *
+     * @param seed Seed.
+     * @param i Table entry for first subcycle generator.
+     * @param j Table entry for second subcycle generator.
+     * @throws InsufficientDataException if {@code i == j}.
+     * @throws OutOfRangeException if {@code i < 0} or
+     * {@code i >= numberOfSubcycleGenerators()}.
+     * @throws OutOfRangeException if {@code j < 0} or
+     * {@code j >= numberOfSubcycleGenerators()}.
+     */
+    public TwoCmres(Integer seed,
+                    int i,
+                    int j) {
+        this(seed, FACTORY.get(i), FACTORY.get(j));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public long next() {
+        xx = x.transform(xx);
+        yy = y.transform(yy);
+
+        return xx + yy;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String toString() {
+        return super.toString() + " (" + x + " + " + y + ")";
+    }
+
+    /**
+     * @return the number of subcycle generators.
+     */
+    public static int numberOfSubcycleGenerators() {
+        return FACTORY.numberOfSubcycleGenerators();
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected byte[] getStateInternal() {
+        return NumberFactory.makeByteArray(new long[] { xx, yy });
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected void setStateInternal(byte[] s) {
+        if (s.length != 16) {
+            throw new InsufficientDataException();
+        }
+
+        final long[] state = NumberFactory.makeLongArray(s);
+        xx = state[0];
+        yy = state[1];
+    }
+
+    /**
+     * @param seed Seed.
+     */
+    private void setSeedInternal(int seed) {
+        // The seeding procedure consists in going away from some
+        // point known to be in the cycle.
+        // The total number of calls to the "transform" method will
+        // not exceed about 130,000 (which is negligible as seeding
+        // will not occur more than once in normal usage).
+
+        // Make two positive 16-bits integers.
+        final long s = NumberFactory.makeLong(0, seed); // s >= 0
+        final int xMax = (int) (s & 0xffff + SEED_GUARD);
+        final int yMax = (int) ((s >> 16) + SEED_GUARD);
+
+        if (xMax < 0 ||
+            yMax < 0) {
+            throw new MathInternalError();
+        }
+
+        xx = x.getStart();
+        for (int i = xMax; i > 0; i--) {
+            xx = x.transform(xx);
+        }
+
+        yy = y.getStart();
+        for (int i = yMax; i > 0; i--) {
+            yy = y.transform(yy);
+        }
+    }
+
+    /**
+     * Subcycle generator.
+     * Class is immutable.
+     */
+    static class Cmres {
+        /** Cycle start. */
+        private final int start;
+        /** Multiplier. */
+        private final long multiply;
+        /** Rotation. */
+        private final int rotate;
+
+        /**
+         * @param multiply Multiplier.
+         * @param rotate Positive number. Must be in {@code [0, 64]}.
+         * @param start Cycle start.
+         */
+        Cmres(long multiply,
+              int rotate,
+              int start) {
+            this.multiply = multiply;
+            this.rotate = rotate;
+            this.start = start;
+        }
+
+        /** {@inheritDoc} */
+        @Override
+        public String toString() {
+            final String sep = ", ";
+            // Use hexadecimal for "multiplier" field.
+            final String m = String.format((java.util.Locale) null, "0x%016xL", multiply);
+            return "Cmres: [" + m + sep + rotate + sep + start + "]";
+        }
+
+        /**
+         * @return the multiplier.
+         */
+        public long getMultiply() {
+            return multiply;
+        }
+
+        /**
+         * @return the cycle start.
+         */
+        public int getStart() {
+            return start;
+        }
+
+        /**
+         * @param state Current state.
+         * @return the new state.
+         */
+        long transform(long state) {
+            long s = state;
+            s *= multiply;
+            s = rotl(s);
+            s -= state;
+            return s;
+        }
+
+        /**
+         * @param state State.
+         * @return the rotated state.
+         */
+        private long rotl(long state) {
+            return (state << rotate) | (state >>> (64 - rotate));
+        }
+
+        /** Factory. */
+        static class Factory {
+            /** List of good "Cmres" subcycle generators. */
+            private static final List<Cmres> TABLE = new ArrayList<Cmres>();
+
+            /**
+             * Populates the table.
+             * It lists parameters known to be good (provided in
+             * the article referred to above).
+             * To maintain compatibility, new entries must be added
+             * only at the end of the table.
+             */
+            static {
+                add(0xedce446814d3b3d9L, 33, 0x13b572e7);
+                add(0xc5b3cf786c806df7L, 33, 0x13c8e18a);
+                add(0xdd91bbb8ab9e0e65L, 31, 0x06dd03a6);
+                add(0x7b69342c0790221dL, 31, 0x1646bb8b);
+                add(0x0c72c0d18614c32bL, 33, 0x06014a3d);
+                add(0xd8d98c13bebe26c9L, 33, 0x014e8475);
+                add(0xcb039dc328bbc40fL, 31, 0x008684bd);
+                add(0x858c5ef3c021ed2fL, 32, 0x0dc8d622);
+                add(0x4c8be96bfc23b127L, 33, 0x0b6b20cc);
+                add(0x11eab77f808cf641L, 32, 0x06534421);
+                add(0xbc9bd78810fd28fdL, 31, 0x1d9ba40d);
+                add(0x0f1505c780688cb5L, 33, 0x0b7b7b67);
+                add(0xadc174babc2053afL, 31, 0x267f4197);
+                add(0x900b6b82b31686d9L, 31, 0x023c6985);
+                // Add new entries here.
+            }
+
+            /**
+             * @return the number of subcycle generators.
+             */
+            int numberOfSubcycleGenerators() {
+                return TABLE.size();
+            }
+
+            /**
+             * @param index Index into the list of available generators.
+             * @return the subcycle generator entry at index {@code index}.
+             */
+            Cmres get(int index) {
+                if (index < 0 ||
+                    index >= TABLE.size()) {
+                    throw new OutOfRangeException(index, 0, TABLE.size());
+                }
+
+                return TABLE.get(index);
+            }
+
+            /**
+             * Adds an entry to the {@link Factory#TABLE}.
+             *
+             * @param multiply Multiplier.
+             * @param rotate Rotate.
+             * @param start Cycle start.
+             */
+            private static void add(long multiply,
+                                    int rotate,
+                                    int start) {
+                // Sanity check: if there are duplicates, the class initialization
+                // will fail (and the JVM will report "NoClassDefFoundError").
+                for (Cmres sg : TABLE) {
+                    if (multiply == sg.getMultiply()) {
+                        throw new MathInternalError();
+                    }
+                }
+
+                TABLE.add(new Cmres(multiply, rotate, start));
+            }
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source64/XorShift1024Star.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source64/XorShift1024Star.java b/src/main/java/org/apache/commons/math4/rng/internal/source64/XorShift1024Star.java
new file mode 100644
index 0000000..c6bcfaa
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source64/XorShift1024Star.java
@@ -0,0 +1,108 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.math4.rng.internal.source64;
+
+import java.util.Arrays;
+import org.apache.commons.math4.exception.InsufficientDataException;
+import org.apache.commons.math4.rng.internal.util.NumberFactory;
+
+/**
+ * A fast RNG.
+ *
+ * @see <a href="http://xorshift.di.unimi.it/xorshift1024star.c">
+ * Original source code</a>
+ *
+ * @since 4.0
+ */
+public class XorShift1024Star extends LongProvider {
+    /** Size of the state vector. */
+    private static final int SEED_SIZE = 16;
+    /** State. */
+    private final long[] state = new long[SEED_SIZE];
+    /** Index in "state" array. */
+    private int index;
+
+    /**
+     * Creates a new instance.
+     *
+     * @param seed Initial seed.
+     * If the length is larger than 16, only the first 16 elements will
+     * be used; if smaller, the remaining elements will be automatically
+     * set.
+     */
+    public XorShift1024Star(long[] seed) {
+        setSeedInternal(seed);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected byte[] getStateInternal() {
+        final long[] s = Arrays.copyOf(state, SEED_SIZE + 1);
+        s[SEED_SIZE] = index;
+
+        return NumberFactory.makeByteArray(s);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected void setStateInternal(byte[] s) {
+        if (s.length != (SEED_SIZE + 1) * 8) {
+            throw new InsufficientDataException();
+        }
+
+        final long[] tmp = NumberFactory.makeLongArray(s);
+
+        System.arraycopy(tmp, 0, state, 0, SEED_SIZE);
+        index = (int) tmp[SEED_SIZE];
+    }
+
+    /**
+     * Seeds the RNG.
+     *
+     * @param seed Seed.
+     */
+    private void setSeedInternal(long[] seed) {
+        // Reset the whole state of this RNG (i.e. "state" and "index").
+        // Seeding procedure is not part of the reference code.
+
+        System.arraycopy(seed, 0, state, 0, Math.min(seed.length, state.length));
+
+        if (seed.length < SEED_SIZE) {
+            for (int i = seed.length; i < SEED_SIZE; i++) {
+                state[i] = 26021969L * i;
+            }
+            for (int i = SEED_SIZE - 1; i > seed.length; i--) {
+                state[i] ^= state[SEED_SIZE - i - 1];
+            }
+
+            state[seed.length] = 0x8000000000000000L; // Ensuring non-zero initial array.
+        }
+
+        index = 0;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public long next() {
+        final long s0 = state[index];
+        long s1 = state[index = (index + 1) & 15];
+        s1 ^= s1 << 31; // a
+        state[index] = s1 ^ s0 ^ (s1 >>> 11) ^ (s0 >>> 30); // b,c
+        return state[index] * 1181783497276652981L;
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/source64/package-info.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/source64/package-info.java b/src/main/java/org/apache/commons/math4/rng/internal/source64/package-info.java
new file mode 100644
index 0000000..8afab2c
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/source64/package-info.java
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * <h3>
+ * Concrete algorithms for {@code long}-based sources of randomness
+ * </h3>
+ *
+ * <p>
+ * <b>For internal use only:</b> Direct access to classes in this package
+ * is discouraged, as they could be modified without notice.
+ * </p>
+ *
+ * <p><b>Notes for developers</b></p>
+ *
+ * <ul>
+ *  <li>
+ *   A source of randomness must inherit from
+ *   {@link org.apache.commons.math4.rng.internal.source64.LongProvider}
+ *  </li>
+ *  <li>
+ *   The "provider" must specify <em>one</em> way for setting the seed.
+ *   For a given seed, the generated sequence must always be the same.
+ *  </li>
+ *  <li>
+ *   The "provider" must implement methods {@code getStateInternal} and
+ *   {@code setStateInternal} in order to save and restore the state of an
+ *   instance (cf. {@link org.apache.commons.math4.rng.internal.BaseProvider}).
+ *  </li>
+ *  <li>
+ *   When a new class is implemented here, user-access to it must be provided
+ *   through associated {@link org.apache.commons.math4.rng.RandomSource
+ *   factory methods}.
+ *  </li>
+ * </ul>
+ */
+
+package org.apache.commons.math4.rng.internal.source64;

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/util/Int2Long.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/util/Int2Long.java b/src/main/java/org/apache/commons/math4/rng/internal/util/Int2Long.java
new file mode 100644
index 0000000..d423c08
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/util/Int2Long.java
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.util;
+
+/**
+ * Converts a {@code Integer} to an {@code Long}.
+ *
+ * @since 4.0
+ */
+public class Int2Long implements SeedConverter<Integer, Long> {
+    /** {@inheritDoc} */
+    @Override
+    public Long convert(Integer seed) {
+        final int s = seed;
+        return NumberFactory.makeLong(s, ~s);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String toString() {
+        return getClass().getSimpleName();
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/util/IntArray2Int.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/util/IntArray2Int.java b/src/main/java/org/apache/commons/math4/rng/internal/util/IntArray2Int.java
new file mode 100644
index 0000000..030895d
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/util/IntArray2Int.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.util;
+
+/**
+ * Creates a single value by "xor" of all the values in the input array.
+ *
+ * @since 4.0
+ */
+public class IntArray2Int implements SeedConverter<int[], Integer> {
+    /** {@inheritDoc} */
+    @Override
+    public Integer convert(int[] seed) {
+        int out = 0;
+        for (int i = 0; i < seed.length; i++) {
+            out ^= seed[i];
+        }
+
+        return out;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String toString() {
+        return getClass().getSimpleName();
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/util/IntArray2LongArray.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/util/IntArray2LongArray.java b/src/main/java/org/apache/commons/math4/rng/internal/util/IntArray2LongArray.java
new file mode 100644
index 0000000..399de7f
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/util/IntArray2LongArray.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.util;
+
+/**
+ * Creates a {@code long[]} from an {@code int[]}.
+ *
+ * @since 4.0
+ */
+public class IntArray2LongArray implements SeedConverter<int[], long[]> {
+    /** {@inheritDoc} */
+    @Override
+    public long[] convert(int[] seed) {
+        final int outSize = (seed.length + 1) / 2;
+        final long[] out = new long[outSize];
+        for (int i = 0; i < outSize; i++) {
+            final int lo = seed[i];
+            final int hi = outSize + i < seed.length ? seed[outSize + i] : 0;
+            out[i] = NumberFactory.makeLong(hi, lo) ;
+        }
+
+        return out;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String toString() {
+        return getClass().getSimpleName();
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/util/Long2Int.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/util/Long2Int.java b/src/main/java/org/apache/commons/math4/rng/internal/util/Long2Int.java
new file mode 100644
index 0000000..638b173
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/util/Long2Int.java
@@ -0,0 +1,36 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.util;
+
+/**
+ * Converts a {@code Long} to an {@code Integer}.
+ *
+ * @since 4.0
+ */
+public class Long2Int implements SeedConverter<Long, Integer> {
+    /** {@inheritDoc} */
+    @Override
+    public Integer convert(Long seed) {
+        return NumberFactory.makeInt(seed);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String toString() {
+        return getClass().getSimpleName();
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/util/Long2IntArray.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/util/Long2IntArray.java b/src/main/java/org/apache/commons/math4/rng/internal/util/Long2IntArray.java
new file mode 100644
index 0000000..84e5016
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/util/Long2IntArray.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.util;
+
+import org.apache.commons.math4.rng.internal.source64.SplitMix64;
+
+/**
+ * Uses a {@code long} value to seed a {@link SplitMix64} RNG and
+ * create a {@code int[]} with the requested number of random
+ * values.
+ *
+ * @since 4.0
+ */
+public class Long2IntArray implements SeedConverter<Long, int[]> {
+    /** Size of the output array. */
+    private final int size;
+
+    /**
+     * @param size Size of the output array.
+     */
+    public Long2IntArray(int size) {
+        this.size = size;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int[] convert(Long seed) {
+        return SeedFactory.createIntArray(size, new SplitMix64(seed));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + "(size=" + size + ")";
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/util/Long2LongArray.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/util/Long2LongArray.java b/src/main/java/org/apache/commons/math4/rng/internal/util/Long2LongArray.java
new file mode 100644
index 0000000..9d8b700
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/util/Long2LongArray.java
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.util;
+
+import org.apache.commons.math4.rng.internal.source64.SplitMix64;
+
+/**
+ * Uses a {@code Long} value to seed a {@link SplitMix64} RNG and
+ * create a {@code long[]} with the requested number of random
+ * values.
+ *
+ * @since 4.0
+ */
+public class Long2LongArray implements SeedConverter<Long, long[]> {
+    /** Size of the output array. */
+    private final int size;
+
+    /**
+     * @param size Size of the output array.
+     */
+    public Long2LongArray(int size) {
+        this.size = size;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public long[] convert(Long seed) {
+        final long[] out = new long[size];
+        final SplitMix64 rng = new SplitMix64(seed);
+        for (int i = 0; i < size; i++) {
+            out[i] = rng.nextLong();
+        }
+
+        return out;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + "(size: " + size + ")";
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/util/LongArray2IntArray.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/util/LongArray2IntArray.java b/src/main/java/org/apache/commons/math4/rng/internal/util/LongArray2IntArray.java
new file mode 100644
index 0000000..67b2ba8
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/util/LongArray2IntArray.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.util;
+
+/**
+ * Creates an {@code int[]} from a {@code long[]}.
+ *
+ * @since 4.0
+ */
+public class LongArray2IntArray implements SeedConverter<long[], int[]> {
+    /** {@inheritDoc} */
+    @Override
+    public int[] convert(long[] seed) {
+        final int[] out = new int[seed.length * 2];
+        for (int i = 0; i < seed.length; i++) {
+            final long current = seed[i];
+            out[i] = NumberFactory.extractLo(current);
+            out[seed.length + i] = NumberFactory.extractHi(current);
+        }
+
+        return out;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String toString() {
+        return getClass().getSimpleName();
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/util/LongArray2Long.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/util/LongArray2Long.java b/src/main/java/org/apache/commons/math4/rng/internal/util/LongArray2Long.java
new file mode 100644
index 0000000..4556aaf
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/util/LongArray2Long.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.util;
+
+/**
+ * Creates a single value by "xor" of all the values in the input array.
+ *
+ * @since 4.0
+ */
+public class LongArray2Long implements SeedConverter<long[], Long> {
+    /** {@inheritDoc} */
+    @Override
+    public Long convert(long[] seed) {
+        long out = 0;
+        for (int i = 0; i < seed.length; i++) {
+            out ^= seed[i];
+        }
+
+        return out;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String toString() {
+        return getClass().getSimpleName();
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/6ddf4769/src/main/java/org/apache/commons/math4/rng/internal/util/LongMixInt.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/rng/internal/util/LongMixInt.java b/src/main/java/org/apache/commons/math4/rng/internal/util/LongMixInt.java
new file mode 100644
index 0000000..e30a072
--- /dev/null
+++ b/src/main/java/org/apache/commons/math4/rng/internal/util/LongMixInt.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math4.rng.internal.util;
+
+import org.apache.commons.math4.rng.internal.source64.SplitMix64;
+
+/**
+ * Uses a {@code long} value to seed a {@link SplitMix64} RNG and
+ * create an {@code int[]} with the requested number of random
+ * values.
+ *
+ * @since 4.0
+ */
+public class LongMixInt implements SeedConverter<Long, int[]> {
+    /** Size of the output array. */
+    private final int size;
+
+    /**
+     * @param size Size of the output array.
+     */
+    public LongMixInt(int size) {
+        this.size = size;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public int[] convert(Long seed) {
+        return SeedFactory.createIntArray(size, new SplitMix64(seed));
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + "(size=" + size + ")";
+    }
+}


Mime
View raw message