RandomStreamBase.java

/*
 * Class:        RandomStreamBase
 * Description:  Base class of all random number generators
 * Environment:  Java
 * Software:     SSJ 
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author       
 * @since
 *
 *
 * Licensed 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 umontreal.ssj.rng;
 
import java.io.Serializable;

public abstract class RandomStreamBase implements CloneableRandomStream, Serializable {
 
   private static final long serialVersionUID = 70510L;
   // La date de modification a l'envers, lire 10/05/2007
 
   // constants
   protected static double invtwo24 = 5.9604644775390625e-8; // 2^(-24)
   private static double EPSILON = 5.5511151231257827e-17; // 2^(-54)
 
   protected String name = null;
 
   // prec53 keeps track if the precision has been increased or not.
   protected boolean prec53 = false;
   protected boolean anti = false; // Deprecated.
 
   public abstract void resetStartStream();
 
   public abstract void resetStartSubstream();
 
   public abstract void resetNextSubstream();
 
   public abstract String toString();

   public void increasedPrecision(boolean incp) {
      prec53 = incp;
   }

   protected abstract double nextValue();

   public double nextDouble() {
      double u = nextValue();
      if (prec53)
         u = (u + nextValue() * invtwo24) % 1.0 + EPSILON;
      if (anti)
         return 1.0 - u;
      else
         return u;
   }

   public void nextArrayOfDouble(double[] u, int start, int n) {
      if (u.length == 0)
         throw new NullPointerException("The array must be initialized.");
      if (u.length < n + start)
         throw new IndexOutOfBoundsException("The array is too small.");
      if (start < 0)
         throw new IndexOutOfBoundsException("Must start at a " + "non-negative index.");
      if (n < 0)
         throw new IllegalArgumentException("Must have a non-negative " + "number of elements.");
 
      for (int ii = start; ii < start + n; ii++)
         u[ii] = nextDouble();
   }

   public int nextInt(int i, int j) {
      if (i > j)
         throw new IllegalArgumentException(i + " is larger than " + j + ".");
      // This works even for an interval [0, 2^31 - 1]. It would not with
      // return i + (int)(nextDouble() * (j - i + 1));
      return i + (int) (nextDouble() * (j - i + 1.0));
   }

   public void nextArrayOfInt(int i, int j, int[] u, int start, int n) {
      if (u == null)
         throw new NullPointerException("The array must be " + "initialized.");
      if (u.length < n + start)
         throw new IndexOutOfBoundsException("The array is too small.");
      if (start < 0)
         throw new IndexOutOfBoundsException("Must start at a " + "non-negative index.");
      if (n < 0)
         throw new IllegalArgumentException("Must have a non-negative " + "number of elements.");
 
      for (int ii = start; ii < start + n; ii++)
         u[ii] = nextInt(i, j);
   }

   @Deprecated
   public String formatState() {
      return toString();
   }

   @Deprecated
   public String formatStateFull() {
      throw new UnsupportedOperationException("   call the toStringFull() method instead.");
   }

   public RandomStreamBase clone() {
      RandomStreamBase retour = null;
      try {
         retour = (RandomStreamBase) super.clone();
      } catch (CloneNotSupportedException cnse) {
         cnse.printStackTrace(System.err);
      }
      return retour;
   }
 
}