Monte-Carlo API

An Engine Task is a general-purpose task, it is used when any computation which doesn't include runnig Monte-Carlo simulation needs to be done. The top-level task, submitted to the PAMonteCarlo class is an engine task. An engine task can, through the access to two interfaces (the Executor and the Simulator), spawn children engine tasks or simulation sets.

public interface EngineTask<T extends Serializable> extends Serializable {

   /**
    * Defines a general purpose task which can be run by the Monte-Carlo framework
    *
    * @param simulator gives the possibility to schedule children simulation sets
    * @param executor  gives the possibility to schedule children engine tasks
    * @return the result of this task
    */
   public T run(Simulator simulator, Executor executor);

}

A Simulation Set is a specific task for running Monte-Carlo simulations. It is given a random number generator and can use it to generate random double numbers which are by default in the uniform distribution. Classes from the SSJ package can be used to convert this distribution to any wanted one. Unlike the Engine Task, the Simulation Set cannot spawn other tasks and is therefore a "terminal task".

public interface SimulationSet<T extends Serializable> extends Serializable {

   /**
    * Defines a Monte-Carlo set of successive experiences, a Random generator is given as a
 parameter
    *
    * A list of double values is expected as output, result of the successive experiences.
    * These experiences can be independant or correlated, this choice is left to the user inside
 the implementation of this method.
    *
    * @param rng random number generator
    * @return a list of double values
    */
   T simulate(final RandomStream rng);
}

A simulation set task will return as output a huge number of values (e.g. arrays of size 10000 or more). In general, these results are not the result of the general algorithm which uses the Monte-Carlo method. Therefore, a post-treatment needs to be done on this big array. Of course, this post-treatment could be done by an engine task that spawned the simulation set task, but in that case, the big array would be tranferred by the network from the Worker which handles the simulation set to the worker which handles the parent engine task. The Simulation Set Post Process avoids this tranfer, and allows to do some computations on the same machine which generated the Monte-Carlo simulations.

public interface SimulationSetPostProcess<T extends Serializable, R extends Serializable> {

   /**
    * Defines a post-processing of results received from a simulation set
    * @param experiencesResults results receive from a Simulation Set task
    * @return the result of the post processing
    */
   R postprocess(T experiencesResults);
}

Some basic Simulation Sets are provided as an example. These basic processes are widely used in the financial risk management theory. An example of such a process is the Geometric Brownian Motion:

/**
* Simulating geometric Brownian motion. This equation is the exact solution of the geometrix
 brownian motion SDE.
* @param s0 Initial value at t=0 of geometric Brownian
* @param mu Drift term
* @param sigma Volatility
* @param t time
* @param N number of experiences
*/
public GeometricBrownianMotion(double s0, double mu, double sigma, double t, int N)

Two basic example applications are provided. The first one computes PI using the Monte-Carlo method (it's only a theoretic approach as the method is very unefficient to compute PI at a good precision). The second example is an European Option Pricing from the financial risk analysis world. Both examples can be found in the subpackage example of the monte-carlo package. A script exists to launch the European Option and is located at PROACTIVE/examples/montecarlo