RandomVariateGenWithCache (Java Libraries for Stochastic Simulation)

java.lang.Object
- umontreal.iro.lecuyer.randvar.RandomVariateGen
- - umontreal.iro.lecuyer.randvar.RandomVariateGenWithCache

```
public class RandomVariateGenWithCache
extends RandomVariateGen
```
This class represents a random variate generator whose values are cached for more efficiency when using common random numbers. An object from this class is constructed with a reference to a RandomVariateGen instance used to get the random numbers. These numbers are stored in an internal array to be retrieved later. The dimension of the array increases as the values are generated. If the nextDouble method is called after the object is reset (by calling setCachedValues), it gives back the cached values instead of computing new ones. If the cache is exhausted before the generator is reset, new values are computed and added to the cache.
Such caching allows for a better performance with common random numbers, when generating random variates is time-consuming. However, using such caching may lead to memory problems if a large quantity of random numbers are needed.

Constructor Summary

Constructors
Constructor and Description
`RandomVariateGenWithCache(RandomVariateGen rvg)` Constructs a new cached random variate generator with internal generator `rvg`.
`RandomVariateGenWithCache(RandomVariateGen rvg, int initialCapacity)` Constructs a new cached random variate generator with internal generator `rvg`.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`clearCache()` Clears the cached values for this cached generator.
`RandomVariateGen`	`getCachedGen()` Returns a reference to the random variate generator whose values are cached.
`DoubleArrayList`	`getCachedValues()` Returns an array list containing the values cached by this random variate generator.
`int`	`getCacheIndex()` Return the index of the next cached value that will be returned by the generator.
`Distribution`	`getDistribution()` Returns the `Distribution` used by this generator.
`int`	`getNumCachedValues()` Returns the total number of values cached by this generator.
`RandomStream`	`getStream()` Returns the `RandomStream` used by this generator.
`void`	`initCache()` Resets this generator to recover values from the cache.
`boolean`	`isCaching()` Determines if the random variate generator is caching values, default being `true`.
`void`	`nextArrayOfDouble(double[] v, int start, int n)` Generates `n` random numbers from the continuous distribution contained in this object.
`double`	`nextDouble()` Generates a random number from the continuous distribution contained in this object.
`void`	`setCachedGen(RandomVariateGen rvg)` Sets the random variate generator whose values are cached to `rvg`.
`void`	`setCachedValues(DoubleArrayList values)` Sets the array list containing the cached values to `values`.
`void`	`setCacheIndex(int newIndex)` Sets the index, in the cache, of the next value returned by `nextDouble`.
`void`	`setCaching(boolean caching)` Sets the caching indicator to `caching`.

Methods inherited from class umontreal.iro.lecuyer.randvar.RandomVariateGen
setStream

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RandomVariateGenWithCache
```
public RandomVariateGenWithCache(RandomVariateGen rvg)
```
    Constructs a new cached random variate generator with internal generator rvg.
    
    Parameters:
    rvg - the random variate generator whose values are cached.
    
    Throws:
    
    java.lang.NullPointerException - if rvg is null.
  - RandomVariateGenWithCache
```
public RandomVariateGenWithCache(RandomVariateGen rvg,
                         int initialCapacity)
```
    Constructs a new cached random variate generator with internal generator rvg. The initialCapacity parameter is used to set the initial capacity of the internal array which can grow as needed; it does not limit the maximal number of cached values.
    
    Parameters:
    rvg - the random variate generator whose values are cached.
    initialCapacity - the number of cached values.
    
    Throws:
    
    java.lang.NullPointerException - if rvg is null.
- Method Detail
  - isCaching
```
public boolean isCaching()
```
    Determines if the random variate generator is caching values, default being true. When caching is turned OFF, the nextDouble method simply calls the corresponding method on the internal random variate generator, without storing the generated values.
    
    Returns:
    the caching indicator.
  - setCaching
```
public void setCaching(boolean caching)
```
    Sets the caching indicator to caching. If caching is turned OFF, this method calls clearCache to clear the cached values.
    
    Parameters:
    caching - the new value of the caching indicator.
  - getCachedGen
```
public RandomVariateGen getCachedGen()
```
    Returns a reference to the random variate generator whose values are cached.
    
    Returns:
    a reference to the random variate generator whose values are cached.
  - setCachedGen
```
public void setCachedGen(RandomVariateGen rvg)
```
    Sets the random variate generator whose values are cached to rvg. If the generator is changed, the clearCache method is called.
    
    Parameters:
    rvg - the new random variate generator whose values are cached.
    
    Throws:
    
    java.lang.NullPointerException - if rvg is null.
  - clearCache
```
public void clearCache()
```
    Clears the cached values for this cached generator. Any subsequent call will then obtain new values from the internal generator.
  - initCache
```
public void initCache()
```
    Resets this generator to recover values from the cache. Subsequent calls to nextDouble will return the cached random values until all the values are returned. When the array of cached values is exhausted, the internal random variate generator is used to generate new values which are added to the internal array as well. This method is equivalent to calling setCacheIndex.
  - getNumCachedValues
```
public int getNumCachedValues()
```
    Returns the total number of values cached by this generator.
    
    Returns:
    the total number of cached values.
  - getCacheIndex
```
public int getCacheIndex()
```
    Return the index of the next cached value that will be returned by the generator. If the cache is exhausted, the returned value corresponds to the value returned by getNumCachedValues, and a subsequent call to nextDouble will generate a new variate rather than reading a previous one from the cache. If caching is disabled, this always returns 0.
    
    Returns:
    the index of the next cached value.
  - setCacheIndex
```
public void setCacheIndex(int newIndex)
```
    Sets the index, in the cache, of the next value returned by nextDouble. If newIndex is 0, this is equivalent to calling initCache. If newIndex is getNumCachedValues, subsequent calls to nextDouble will add new values to the cache.
    
    Parameters:
    newIndex - the new index.
    
    Throws:
    
    java.lang.IllegalArgumentException - if newIndex is negative or greater than or equal to the cache size.
  - getCachedValues
```
public DoubleArrayList getCachedValues()
```
    Returns an array list containing the values cached by this random variate generator.
    
    Returns:
    the array of cached values.
  - setCachedValues
```
public void setCachedValues(DoubleArrayList values)
```
    Sets the array list containing the cached values to values. This resets the cache index to the size of the given array.
    
    Parameters:
    values - the array list of cached values.
    
    Throws:
    
    java.lang.NullPointerException - if values is null.
  - nextDouble
```
public double nextDouble()
```
    Description copied from class: RandomVariateGen
    
    Generates a random number from the continuous distribution contained in this object. By default, this method uses inversion by calling the inverseF method of the distribution object. Alternative generating methods are provided in subclasses.
    
    Overrides:
    
    nextDouble in class RandomVariateGen
    
    Returns:
    the generated value
  - nextArrayOfDouble
```
public void nextArrayOfDouble(double[] v,
                     int start,
                     int n)
```
    Description copied from class: RandomVariateGen
    
    Generates n random numbers from the continuous distribution contained in this object. These numbers are stored in the array v, starting from index start. By default, this method calls nextDouble() n times, but one can override it in subclasses for better efficiency.
    
    Overrides:
    
    nextArrayOfDouble in class RandomVariateGen
    
    Parameters:
    v - array in which the variates will be stored
    start - starting index, in v, of the new variates
    n - number of variates to generate
  - getStream
```
public RandomStream getStream()
```
    Description copied from class: RandomVariateGen
    
    Returns the RandomStream used by this generator.
    
    Overrides:
    
    getStream in class RandomVariateGen
    
    Returns:
    the stream associated to this object
  - getDistribution
```
public Distribution getDistribution()
```
    Description copied from class: RandomVariateGen
    
    Returns the Distribution used by this generator.
    
    Overrides:
    
    getDistribution in class RandomVariateGen
    
    Returns:
    the distribution associated to that object

Class RandomVariateGenWithCache

Constructor Summary

Method Summary

Methods inherited from class umontreal.iro.lecuyer.randvar.RandomVariateGen

Methods inherited from class java.lang.Object

Constructor Detail

RandomVariateGenWithCache

RandomVariateGenWithCache

Method Detail

isCaching

setCaching

getCachedGen

setCachedGen

clearCache

initCache

getNumCachedValues

getCacheIndex

setCacheIndex

getCachedValues

setCachedValues

nextDouble

nextArrayOfDouble

getStream

getDistribution