RandomStreamWithCache.java

/*
 * Class:        RandomStreamWithCache
 * Description:  random stream whose uniforms are cached for more efficiency
 * 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 cern.colt.list.DoubleArrayList;

public class RandomStreamWithCache implements RandomStream {
   private RandomStream stream;
   private DoubleArrayList values;
   private int index = 0;
   private boolean caching = true;

   public RandomStreamWithCache(RandomStream stream) {
      if (stream == null)
         throw new NullPointerException("The given random stream cannot be null");
      this.stream = stream;
      values = new DoubleArrayList();
   }

   public RandomStreamWithCache(RandomStream stream, int initialCapacity) {
      if (stream == null)
         throw new NullPointerException("The given random stream cannot be null");
      this.stream = stream;
      values = new DoubleArrayList(initialCapacity);
   }

   public boolean isCaching() {
      return caching;
   }

   public void setCaching(boolean caching) {
      if (this.caching && !caching)
         clearCache();
      this.caching = caching;
   }

   public RandomStream getCachedStream() {
      return stream;
   }

   public void setCachedStream(RandomStream stream) {
      if (stream == null)
         throw new NullPointerException("The given random stream cannot be null");
      if (stream == this.stream)
         return;
      this.stream = stream;
      clearCache();
   }

   public void clearCache() {
      // values.clear();
      // Keep the array previously returned by getCachedValues
      // intact to allow caching values for several
      // replications.
      values = new DoubleArrayList();
      index = 0;
   }

   public void initCache() {
      index = 0;
   }

   public int getNumCachedValues() {
      return values.size();
   }

   public int getCacheIndex() {
      return index;
   }

   public void setCacheIndex(int newIndex) {
      if (newIndex < 0 || newIndex > values.size())
         throw new IllegalArgumentException("newIndex must not be negative or greater than the cache size");
      index = newIndex;
   }

   public DoubleArrayList getCachedValues() {
      return values;
   }

   public void setCachedValues(DoubleArrayList values) {
      if (values == null)
         throw new NullPointerException();
      this.values = values;
      index = values.size();
   }
 
   public void resetStartStream() {
      stream.resetStartStream();
   }
 
   public void resetStartSubstream() {
      stream.resetStartSubstream();
   }
 
   public void resetNextSubstream() {
      stream.resetNextSubstream();
   }
 
   public double nextDouble() {
      if (!caching)
         return stream.nextDouble();
      else if (index >= values.size()) {
         double v = stream.nextDouble();
         values.add(v);
         ++index;
         return v;
      } else
         return values.getQuick(index++);
   }
 
   public void nextArrayOfDouble(double[] u, int start, int n) {
      if (!caching) {
         stream.nextArrayOfDouble(u, start, n);
         return;
      }
      int remainingValues = values.size() - index;
      if (remainingValues < 0)
         remainingValues = 0;
      int ncpy = Math.min(n, remainingValues);
      if (ncpy > 0) {
         System.arraycopy(values.elements(), index, u, start, ncpy);
         index += ncpy;
      }
      int ngen = n - ncpy;
      if (ngen > 0) {
         stream.nextArrayOfDouble(u, start + ncpy, ngen);
         for (int i = ncpy; i < n; i++) {
            values.add(u[start + i]);
            ++index;
         }
      }
   }
 
   public int nextInt(int i, int j) {
      return i + (int) (nextDouble() * (j - i + 1));
   }
 
   public void nextArrayOfInt(int i, int j, int[] u, int start, int n) {
      for (int x = start; x < start + n; x++)
         u[x] = nextInt(i, j);
   }
}