Random contains a variety of random number distributions as static
instance variables as well as a few next* methods for returning the
next psuedo-random value from a distribution. Before using any of the
instance variable distributions, these distributions must be created via
the appropriate create* method. For example,
// initialize Random.uniform
Random.createUniform();
// Random.uniform is now initialized and can be used.
int index = Random.uniform.getNextIntFromTo(0, 100);
Once created a distribution can be used anywhere in your code through the
use of Random's static instance variables. So for example, if you create
the Uniform distribution in your model's begin() method, you can access the
same Uniform distribution in your model's agent code with
Random.uniform. This instance variable should always be
referenced as such, that is, as Random._distribution_name_, and not as
the right hand side of an assignment. Assigning a variable in this way
can lead to unpredictable results when setting the random seed.
In short, code like this:
int index = Random.uniform.nextIntFromTo(0, 10);
Uniform myUniform = Random.uniform; // This is dangerous. Don't do it!!!
...
int index = myUniform.nextIntFromTo(0, 10);
double s = Random.nextCauchy();
In all cases, the distributions use a MersenneTwister as the
source for psuedo-random numbers. The MersenneTwister is a
particularly good generator for simulations as it has an
extremely large period. This generator is seeded on first use
with the current timestamp. However, Random also allows you to set and
get the random seed as well as the random number generator associated
with that seed. Setting a new seed with Random.setSeed
will create a new MersenneTwister with the specified seed and
invalidate any previously created distributions. If you wish to use
a distribution after the seed has been set, you must create it as
described above. Consequently, the following is correct code:
Random.createUniform();
int index = Random.uniform.nextIntFromTo(1, 10);
...
Random.setSeed(1L);
Random.createUniform();
...
int index = Random.uniform.nextIntFromTo(1, 10);
Random.createUniform();
int index = Random.uniform.nextIntFromTo(1, 10);
...
Random.setSeed(1L);
...
int index = Random.uniform.nextIntFromTo(1, 10); // This won't work
Note that Random creates a default random number generator using the current timestamp as the seed. If you do not explicitly set your own seed, the distributions created via the create* calls will use this default generator.
The normal pattern of use then is to create the distributions you want,
and having done so draw randon numbers from those distributions
througout your code via Random's instance variables. For
example:
For more information see the doc for cern.jet.random in the
colt library documentation.
Random.createUniform();
Random.createNormal(.5, .3);
...
int index = Random.uniform.nextIntFromTo(0, 10);
double val = Random.normal.nextDouble();
Custom random number generation still uses the colt library but
bypasses Repast's Random class. You'll need to do this if you
want to use distributions with independent random number streams (random
number generators). The general idea here is to define some
instance variables in your model of the appropriate distribution
types, create your random number generators and then associate these
generators with the distributions you want to use. For example:
import cern.jet.random.*;
import cern.jet.random.engine.MersenneTwister;
...
public class MyModel extends SimModelImpl {
Normal myNormalDist;
Uniform myUniformDist;
...
public void begin() {
MersenneTwister generator1 = new MersenneTwister(123);
MersenneTwister generator2 = new MersenneTwister(321);
myNormalDist = new Normal(1.0, 1.0, generator1);
myUniformDist = new Uniform(generator2);
}
...
public void someMethod() {
int index = myUniformDist.nextIntFromTo(0, 10);
doubl val = myNormalDist.nextDouble();
}
}