package org.jgap.util;


/**
    Implementation of a <b>randomX</b>-compliant class using
    L'Ecuyer's two-sequence generator with a Bays-Durham shuffle, as
    described on page 282 of Press et al., <cite>Numerical Recipes in
    C</cite>, 2nd edition.  Their implementation was constrained by
    the absence of a 64-bit integer data type.  Since Java guarantees
    a <tt>long</tt> to be 64 bit, we can use L'Ecuyer's multiplier and modulus
    directly, rather than flailing around with Schrage's algorithm.
    Further, 64-bit <tt>long</tt> arithmetic allows us to directly combine
    the results from the two generators by adding and taking the modulus of
    one of them, bypassing the subtract and test for negative gimmick used
    in <cite>Numerical Recipes</cite>.

    <p>
    For additional details, see L'Ecuyer's original 1968 paper
    at page 742 of <cite>Communications of the ACM</cite>,
    Vol. 31.

    <p>
    Designed and implemented in July 1996 by
    <a href="http://www.fourmilab.ch/">John Walker</a>,
    <a href="mailto:kelvin@fourmilab.ch">kelvin@fourmilab.ch</a>.
*/
public class randomLEcuyer extends randomX {

    /* L'Ecuyer's recommended multiplier and modulus for the two
       multiplicative congruential generators.  Even though the
       values fit in 32 bits, we declare them as long so that the
       arithmetic in calculating the next value will be automatically
       done in long without need for casting. */

    static final long mul1 = 40014,
                      mod1 = 2147483563,
                      mul2 = 40692,
                      mod2 = 2147483399;
    static final int shuffleSize = 32,       // Shuffle table size
                     warmup = 19;            /* Number of initial warmup
                                                results to "burn" */

    int gen1, gen2, state;
    int [] shuffle;

    //  Constructors

    /** Creates a new pseudorandom number generator, seeded from
        the current time. */

    public randomLEcuyer() {
        shuffle = new int[shuffleSize];
        this.setSeed(System.currentTimeMillis());
    }

    /** Creates a new pseudorandom number generator with a
        specified nonzero seed.

@param seed initial seed for the generator
    */

    public randomLEcuyer(long seed) throws IllegalArgumentException {
        shuffle = new int[shuffleSize];
        this.setSeed(seed);
    }

    //  Seed access

    /** Set seed for generator.  Subsequent values will be based
        on the given nonzero seed.

@param seed seed for the generator
    */

    public void setSeed(long seed) throws IllegalArgumentException {
        int i;

        if (seed == 0) {
            throw new IllegalArgumentException("seed must be nonzero");
        }
        gen1 = gen2 = (int) (seed & 0x7FFFFFFFFL);

        /* "Warm up" the generator for a number of rounds to eliminate
           any residual inflence of the seed. */

        for (i = 0; i < warmup; i++) {
            gen1 = (int) ((gen1 * mul1) % mod1);
        }

        // Fill the shuffle table with values

        for (i = 0; i < shuffleSize; i++) {
            gen1 = (int) ((gen1 * mul1) % mod1);
            shuffle[(shuffleSize - 1) - i] = gen1;
        }
        state = shuffle[0];
    }

    /** Get next byte from generator.

@return the next byte from the generator.
    */

    public byte nextByte() {
        int i;

        gen1 = (int) ((gen1 * mul1) % mod1);   // Cycle generator 1
        gen2 = (int) ((gen2 * mul2) % mod2);   // Cycle generator 2

        /* Extract shuffle table index from most significant part
           of the previous result. */

        i = state / (1 + (((int) mod1) - 1) / shuffleSize);

        // New state is sum of generators modulo one of their moduli

        state = (int) ((((long) shuffle[i]) + gen2) % mod1);

        // Replace value in shuffle table with generator 1 result

        shuffle[i] = gen1;

        return (byte) (state / (1 + (((int) mod1) - 1) / 256));
    }
};