RandomVariateGenWithCache.java

/*
 * Class:        RandomVariateGenWithCache
 * Description:  random variate generator whose values are cached for 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.randvar;
 
import umontreal.ssj.randvar.RandomVariateGen;
import cern.colt.list.DoubleArrayList;
import umontreal.ssj.rng.RandomStream;
import umontreal.ssj.probdist.Distribution;

public class RandomVariateGenWithCache extends RandomVariateGen {
   private RandomVariateGen rvg;
   private DoubleArrayList values;
   private int index = 0;
   private boolean caching = true;

   public RandomVariateGenWithCache(RandomVariateGen rvg) {
      if (rvg == null)
         throw new NullPointerException("The given random variate generator cannot be null");
      this.rvg = rvg;
      values = new DoubleArrayList();
   }

   public RandomVariateGenWithCache(RandomVariateGen rvg, int initialCapacity) {
      if (rvg == null)
         throw new NullPointerException("The given random variate generator cannot be null");
      this.rvg = rvg;
      values = new DoubleArrayList(initialCapacity);
   }

   public boolean isCaching() {
      return caching;
   }

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

   public RandomVariateGen getCachedGen() {
      return rvg;
   }

   public void setCachedGen(RandomVariateGen rvg) {
      if (rvg == null)
         throw new NullPointerException("The given random variate generator cannot be null");
      if (rvg == this.rvg)
         return;
      this.rvg = rvg;
      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 double nextDouble() {
      if (!caching)
         return rvg.nextDouble();
      else if (index >= values.size()) {
         double v = rvg.nextDouble();
         values.add(v);
         ++index;
         return v;
      } else
         return values.getQuick(index++);
   }
 
   public void nextArrayOfDouble(double[] v, int start, int n) {
      if (!caching) {
         rvg.nextArrayOfDouble(v, 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, v, start, ncpy);
         index += ncpy;
      }
      int ngen = n - ncpy;
      if (ngen > 0) {
         rvg.nextArrayOfDouble(v, start + ncpy, ngen);
         for (int i = ncpy; i < n; i++) {
            values.add(v[start + i]);
            ++index;
         }
      }
   }
 
   public RandomStream getStream() {
      return rvg.getStream();
   }
 
   public Distribution getDistribution() {
      return rvg.getDistribution();
   }
}