Class XSTR

  • All Implemented Interfaces:
    java.io.Serializable

    public class XSTR
    extends java.util.Random
    XSTR - Xorshift ThermiteRandom Modified by Bogdan-G 03.06.2016 version 0.0.4
    See Also:
    Serialized Form
    • Constructor Summary

      Constructors 
      Constructor Description
      XSTR()
      Creates a new pseudo random number generator.
      XSTR​(long seed)
      Creates a new pseudo random number generator, starting with the specified seed, using setSeed(seed);.
    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      XSTR clone()  
      long getSeed()
      Returns the current state of the seed, can be used to clone the object
      int next​(int nbits)
      Implementation of George Marsaglia's elegant Xorshift random generator 30% faster and better quality than the built-in java.util.random see also see http://www.javamex.com/tutorials/random_numbers/xorshift.shtml
      boolean nextBoolean()  
      void nextBytes​(byte[] bytes_arr)  
      double nextDouble()  
      float nextFloat()  
      double nextGaussian()  
      int nextInt()  
      int nextInt​(int bound)
      Returns a pseudorandom, uniformly distributed int value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence.
      long nextLong()  
      void setSeed​(long seed)
      Sets the seed for this pseudo random number generator.
      • Methods inherited from class java.util.Random

        doubles, doubles, doubles, doubles, ints, ints, ints, ints, longs, longs, longs, longs
      • Methods inherited from class java.lang.Object

        equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • XSTR_INSTANCE

        public static final XSTR XSTR_INSTANCE
    • Constructor Detail

      • XSTR

        public XSTR()
        Creates a new pseudo random number generator. The seed is initialized to the current time, as if by setSeed(System.currentTimeMillis());.
      • XSTR

        public XSTR​(long seed)
        Creates a new pseudo random number generator, starting with the specified seed, using setSeed(seed);.
        Parameters:
        seed - the initial seed
    • Method Detail

      • nextBoolean

        public boolean nextBoolean()
        Overrides:
        nextBoolean in class java.util.Random
      • nextDouble

        public double nextDouble()
        Overrides:
        nextDouble in class java.util.Random
      • getSeed

        public long getSeed()
        Returns the current state of the seed, can be used to clone the object
        Returns:
        the current seed
      • setSeed

        public void setSeed​(long seed)
        Sets the seed for this pseudo random number generator. As described above, two instances of the same random class, starting with the same seed, produce the same results, if the same methods are called.
        Overrides:
        setSeed in class java.util.Random
        Parameters:
        seed - the new seed
      • clone

        public XSTR clone()
        Overrides:
        clone in class java.lang.Object
        Returns:
        Returns an XSRandom object with the same state as the original
      • next

        public int next​(int nbits)
        Implementation of George Marsaglia's elegant Xorshift random generator 30% faster and better quality than the built-in java.util.random see also see http://www.javamex.com/tutorials/random_numbers/xorshift.shtml
        Overrides:
        next in class java.util.Random
        Parameters:
        nbits - will shift nbits bits
        Returns:
        next seed
      • nextGaussian

        public double nextGaussian()
        Overrides:
        nextGaussian in class java.util.Random
      • nextInt

        public int nextInt​(int bound)
        Returns a pseudorandom, uniformly distributed int value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence. The general contract of nextInt is that one int value in the specified range is pseudorandomly generated and returned. All bound possible int values are produced with (approximately) equal probability. The method nextInt(int bound) is implemented by class Random as if by:
          
         public int nextInt(int bound) {
           if (bound <= 0)
             throw new IllegalArgumentException("bound must be positive");
        
           if ((bound & -bound) == bound)  // i.e., bound is a power of 2
             return (int)((bound * (long)next(31)) >> 31);
        
           int bits, val;
           do {
               bits = next(31);
               val = bits % bound;
           } while (bits - val + (bound-1) < 0);
           return val;
         }
         

        The hedge "approx imately" is used in the foregoing description only because the next method is only approximately an unbiased source of independently chosen bits. If it were a perfect source of randomly chosen bits, then the algorithm shown would choose int values from the stated range with perfect uniformity.

        The algorithm is slightly tricky. It rejects values that would result in an uneven distribution (due to the fact that 2^31 is not divisible by n). The probability of a value being rejected depends on n. The worst case is n=2^30+1, for which the probability of a reject is 1/2, and the expected number of iterations before the loop terminates is 2.

        The algorithm treats the case where n is a power of two specially: it returns the correct number of high-order bits from the underlying pseudo-random number generator. In the absence of special treatment, the correct number of low-order bits would be returned. Linear congruential pseudo-random number generators such as the one implemented by this class are known to have short periods in the sequence of values of their low-order bits. Thus, this special case greatly increases the length of the sequence of values returned by successive calls to this method if n is a small power of two.

        Overrides:
        nextInt in class java.util.Random
        Parameters:
        bound - the upper bound (exclusive). Must be positive.
        Returns:
        the next pseudorandom, uniformly distributed int value between zero (inclusive) and bound (exclusive) from this random number generator's sequence
        Throws:
        java.lang.IllegalArgumentException - if bound is not positive
        Since:
        1.2
      • nextInt

        public int nextInt()
        Overrides:
        nextInt in class java.util.Random
      • nextFloat

        public float nextFloat()
        Overrides:
        nextFloat in class java.util.Random
      • nextLong

        public long nextLong()
        Overrides:
        nextLong in class java.util.Random
      • nextBytes

        public void nextBytes​(byte[] bytes_arr)
        Overrides:
        nextBytes in class java.util.Random