Robust/src/Benchmarks/Scheduling/GC/NON_BAMBOO/JGFMonteCarlo/MonteCarloPath.java

   1 /** Banboo Version  **/
   2
   3 /**************************************************************************
   4  *                                                                         *
   5  *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
   6  *                                                                         *
   7  *                            produced by                                  *
   8  *                                                                         *
   9  *                  Java Grande Benchmarking Project                       *
  10  *                                                                         *
  11  *                                at                                       *
  12  *                                                                         *
  13  *                Edinburgh Parallel Computing Centre                      *
  14  *                                                                         *
  15  *                email: epcc-javagrande@epcc.ed.ac.uk                     *
  16  *                                                                         *
  17  *      Original version of this code by Hon Yau (hwyau@epcc.ed.ac.uk)     *
  18  *                                                                         *
  19  *      This version copyright (c) The University of Edinburgh, 2001.      *
  20  *                         All rights reserved.                            *
  21  *                                                                         *
  22  **************************************************************************/
  23
  24 /**
  25  * Class representing the paths generated by the Monte Carlo engine.
  26  *
  27  * <p>To do list:
  28  * <ol>
  29  *   <li><code>double[] pathDate</code> is not simulated.</li>
  30  * </ol>
  31  *
  32  * @author H W Yau
  33  * @version $Revision: 1.1 $ $Date: 2011/07/13 23:49:52 $
  34  */
  35 public class MonteCarloPath extends PathId {
  36
  37     //------------------------------------------------------------------------
  38     // Instance variables.
  39     //------------------------------------------------------------------------
  40     /**
  41      * Random fluctuations generated as a series of random numbers with
  42      * given distribution.
  43      */
  44     public float[] fluctuations;
  45     /**
  46      * The path values from which the random fluctuations are used to update.
  47      */
  48     public float[] pathValue;
  49     /**
  50      * Integer flag for determining how the return was calculated, when
  51      * used to calculate the mean drift and volatility parameters.
  52      */
  53     public int returnDefinition;
  54     /**
  55      * Value for the mean drift, for use in the generation of the random path.
  56      */
  57     public float expectedReturnRate;
  58     /**
  59      * Value for the volatility, for use in the generation of the random path.
  60      */
  61     public float volatility;
  62     /**
  63      * Number of time steps for which the simulation should act over.
  64      */
  65     public int nTimeSteps;
  66     /**
  67      * The starting value for of the security.
  68      */
  69     public float pathStartValue;
  70     //------------------------------------------------------------------------
  71     // Constructors.
  72     //------------------------------------------------------------------------
  73     /**
  74      * Default constructor.  Needed by the HPT library to start create
  75      * new instances of this class.  The instance variables for this should
  76      * then be initialised with the <code>setInitAllTasks()</code> method.
  77      */
  78     public MonteCarloPath() {
  79         super();
  80         this.expectedReturnRate = (float)0.0;
  81         this.volatility = (float)0.0;
  82         this.pathStartValue = (float)0.0;
  83         this.returnDefinition=1;
  84         this.nTimeSteps=0;
  85     }
  86
  87     /**
  88      * Constructor, using the <code>ReturnPath</code> object to initialise
  89      * the necessary instance variables.
  90      *
  91      * @param returnPath Object used to define the instance variables in
  92      *                   this object.
  93      * @param nTimeSteps The number of time steps for which to generate the
  94      *                   random path.
  95      * @exception DemoException Thrown if there is a problem initialising the
  96      *                          object's instance variables.
  97      */
  98     public MonteCarloPath(ReturnPath returnPath,
  99                           int nTimeSteps) {
 100         /**
 101          * These instance variables are members of PathId class.
 102          */
 103         this.expectedReturnRate = (float)0.0;
 104         this.volatility = (float)0.0;
 105         this.pathStartValue = (float)0.0;
 106         this.returnDefinition=1;
 107
 108         copyInstanceVariables(returnPath);
 109         this.nTimeSteps = nTimeSteps;
 110         this.pathValue = new float[nTimeSteps];
 111         this.fluctuations = new float[nTimeSteps];
 112     }
 113     /**
 114      * Constructor, where the <code>PathId</code> objects is used to ease
 115      * the number of instance variables to pass in.
 116      *
 117      * @param pathId Object used to define the identity of this Path.
 118      * @param returnDefinition How the statistic variables were defined,
 119      *                         according to the definitions in
 120      *                         <code>ReturnPath</code>'s two class variables
 121      *                         <code>COMPOUNDED</code> and
 122      *                         <code>NONCOMPOUNDED</code>.
 123      * @param expectedReturnRate The measured expected return rate for which to generate.
 124      * @param volatility The measured volatility for which to generate.
 125      * @param nTimeSteps The number of time steps for which to generate.
 126      * @exception DemoException Thrown if there is a problem initialising the
 127      *                          object's instance variables.
 128      */
 129     public MonteCarloPath(PathId pathId,
 130                           int returnDefinition,
 131                           float expectedReturnRate,
 132                           float volatility,
 133                           int nTimeSteps) {
 134         /**
 135          * These instance variables are members of PathId class.
 136          * Invoking with this particular signature should point to the
 137          * definition in the PathId class.
 138          */
 139         this.pathStartValue = (float)0.0;
 140
 141         copyInstanceVariables(pathId);
 142         this.returnDefinition   = returnDefinition;
 143         this.expectedReturnRate = expectedReturnRate;
 144         this.volatility         = volatility;
 145         this.nTimeSteps         = nTimeSteps;
 146         this.pathValue          = new float[nTimeSteps];
 147         this.fluctuations       = new float[nTimeSteps];
 148     }
 149     /**
 150      * Constructor, for when the user wishes to define each of the instance
 151      * variables individually.
 152      *
 153      * @param name The name of the security which this Monte Carlo path
 154      *             should represent.
 155      * @param startDate The date when the path starts, in 'YYYYMMDD' format.
 156      * @param endDate The date when the path ends, in 'YYYYMMDD' format.
 157      * @param dTime The interval in the data between successive data points
 158      *              in the generated path.
 159      * @param returnDefinition How the statistic variables were defined,
 160      *                         according to the definitions in
 161      *                         <code>ReturnPath</code>'s two class variables
 162      *                         <code>COMPOUNDED</code> and
 163      *                         <code>NONCOMPOUNDED</code>.
 164      * @param expectedReturnRate The measured mean drift for which to generate.
 165      * @param volatility The measured volatility for which to generate.
 166      * @param nTimeSteps The number of time steps for which to generate.
 167      */
 168     public MonteCarloPath(String name,
 169                           int startDate,
 170                           int endDate,
 171                           float dTime,
 172                           int returnDefinition,
 173                           float expectedReturnRate,
 174                           float volatility,
 175                           int nTimeSteps) {
 176         /**
 177          * These instance variables are members of PathId class.
 178          */
 179         this.name = name;
 180         this.startDate = startDate;
 181         this.endDate = endDate;
 182         this.dTime = dTime;
 183         this.returnDefinition   = returnDefinition;
 184         this.expectedReturnRate = expectedReturnRate;
 185         this.volatility         = volatility;
 186         this.nTimeSteps         = nTimeSteps;
 187         this.pathValue          = new float[nTimeSteps];
 188         this.fluctuations       = new float[nTimeSteps];
 189     }
 190
 191     //------------------------------------------------------------------------
 192     // Methods.
 193     //------------------------------------------------------------------------
 194     //------------------------------------------------------------------------
 195     // Accessor methods for class MonteCarloPath.
 196     // Generated by 'makeJavaAccessor.pl' script.  HWY.  20th January 1999.
 197     //------------------------------------------------------------------------
 198     /**
 199      * Accessor method for private instance variable <code>fluctuations</code>.
 200      *
 201      * @return Value of instance variable <code>fluctuations</code>.
 202      * @exception DemoException thrown if instance variable <code>fluctuations</code>
 203      * is undefined.
 204      */
 205     /*public float[] get_fluctuations() {
 206         return(this.fluctuations);
 207     }*/
 208     /**
 209      * Set method for private instance variable <code>fluctuations</code>.
 210      *
 211      * @param fluctuations the value to set for the instance variable
 212      * <code>fluctuations</code>.
 213      */
 214     public void set_fluctuations(float[] fluctuations) {
 215         this.fluctuations = fluctuations;
 216     }
 217     /**
 218      * Accessor method for private instance variable <code>pathValue</code>.
 219      *
 220      * @return Value of instance variable <code>pathValue</code>.
 221      * @exception DemoException thrown if instance variable <code>pathValue</code>
 222      * is undefined.
 223      */
 224     /*public float[] get_pathValue() {
 225         return(this.pathValue);
 226     }*/
 227     /**
 228      * Set method for private instance variable <code>pathValue</code>.
 229      *
 230      * @param pathValue the value to set for the instance variable <code>pathValue</code>.
 231      */
 232     public void set_pathValue(float[] pathValue) {
 233         this.pathValue = pathValue;
 234     }
 235     /**
 236      * Accessor method for private instance variable <code>returnDefinition</code>.
 237      *
 238      * @return Value of instance variable <code>returnDefinition</code>.
 239      * @exception DemoException thrown if instance variable <code>returnDefinition</code>
 240      * is undefined.
 241      */
 242     /*public int get_returnDefinition() {
 243         return(this.returnDefinition);
 244     }*/
 245     /**
 246      * Set method for private instance variable <code>returnDefinition</code>.
 247      *
 248      * @param returnDefinition the value to set for the instance variable
 249      * <code>returnDefinition</code>.
 250      */
 251     public void set_returnDefinition(int returnDefinition) {
 252         this.returnDefinition = returnDefinition;
 253     }
 254     /**
 255      * Accessor method for private instance variable <code>expectedReturnRate</code>.
 256      *
 257      * @return Value of instance variable <code>expectedReturnRate</code>.
 258      * @exception DemoException thrown if instance variable <code>expectedReturnRate</code>
 259      * is undefined.
 260      */
 261     /*public float get_expectedReturnRate() {
 262         return(this.expectedReturnRate);
 263     }*/
 264     /**
 265      * Set method for private instance variable <code>expectedReturnRate</code>.
 266      *
 267      * @param expectedReturnRate the value to set for the instance variable
 268      * <code>expectedReturnRate</code>.
 269      */
 270     public void set_expectedReturnRate(float expectedReturnRate) {
 271         this.expectedReturnRate = expectedReturnRate;
 272     }
 273     /**
 274      * Accessor method for private instance variable <code>volatility</code>.
 275      *
 276      * @return Value of instance variable <code>volatility</code>.
 277      * @exception DemoException thrown if instance variable <code>volatility</code>
 278      * is undefined.
 279      */
 280     /*public float get_volatility() {
 281         return(this.volatility);
 282     }*/
 283     /**
 284      * Set method for private instance variable <code>volatility</code>.
 285      *
 286      * @param volatility the value to set for the instance variable
 287      * <code>volatility</code>.
 288      */
 289     public void set_volatility(float volatility) {
 290         this.volatility = volatility;
 291     }
 292     /**
 293      * Accessor method for private instance variable <code>nTimeSteps</code>.
 294      *
 295      * @return Value of instance variable <code>nTimeSteps</code>.
 296      * @exception DemoException thrown if instance variable <code>nTimeSteps</code>
 297      * is undefined.
 298      */
 299     /*public int get_nTimeSteps() {
 300         return(this.nTimeSteps);
 301     }*/
 302     /**
 303      * Set method for private instance variable <code>nTimeSteps</code>.
 304      *
 305      * @param nTimeSteps the value to set for the instance variable
 306      * <code>nTimeSteps</code>.
 307      */
 308     public void set_nTimeSteps(int nTimeSteps) {
 309         this.nTimeSteps = nTimeSteps;
 310     }
 311     /**
 312      * Accessor method for private instance variable <code>pathStartValue</code>.
 313      *
 314      * @return Value of instance variable <code>pathStartValue</code>.
 315      * @exception DemoException thrown if instance variable <code>pathStartValue</code>
 316      * is undefined.
 317      */
 318     /*public float get_pathStartValue() {
 319         return(this.pathStartValue);
 320     }*/
 321     /**
 322      * Set method for private instance variable <code>pathStartValue</code>.
 323      *
 324      * @param pathStartValue the value to set for the instance variable
 325      * <code>pathStartValue</code>.
 326      */
 327     public void set_pathStartValue(float pathStartValue) {
 328         this.pathStartValue = pathStartValue;
 329     }
 330     //------------------------------------------------------------------------
 331     /**
 332      * Method for copying the suitable instance variable from a
 333      * <code>ReturnPath</code> object.
 334      *
 335      * @param obj Object used to define the instance variables which
 336      *            should be carried over to this object.
 337      * @exception DemoException thrown if there is a problem accessing the
 338      *                          instance variables from the target objetct.
 339      */
 340     private void copyInstanceVariables(ReturnPath obj) {
 341         //
 342         // Instance variables defined in the PathId object.
 343         this.name = obj.name;
 344         this.startDate = obj.startDate;
 345         this.endDate = obj.endDate;
 346         this.dTime = obj.dTime;
 347         //
 348         // Instance variables defined in this object.
 349         this.returnDefinition   = obj.returnDefinition;
 350         this.expectedReturnRate = obj.expectedReturnRate;
 351         this.volatility         = obj.volatility;
 352     }
 353
 354     /**
 355      * Method for returning a RatePath object from the Monte Carlo data
 356      * generated.
 357      *
 358      * @return a <code>RatePath</code> object representing the generated
 359      *         data.
 360      * @exception DemoException thrown if there was a problem creating
 361      *            the RatePath object.
 362      */
 363     public RatePath getRatePath() {
 364         return(new RatePath(this));
 365     }
 366     /**
 367      * Method for calculating the sequence of fluctuations, based around
 368      * a Gaussian distribution of given mean and variance, as defined
 369      * in this class' instance variables.  Mapping from Gaussian
 370      * distribution of (0,1) to (mean-drift,volatility) is done via
 371      * Ito's lemma on the log of the stock price.
 372      *
 373      * @param randomSeed The psuedo-random number seed value, to start off a
 374      *                   given sequence of Gaussian fluctuations.
 375      * @exception DemoException thrown if there are any problems with
 376      *                          the computation.
 377      */
 378     public boolean computeFluctuationsGaussian(long randomSeed) {
 379         int ntimesteps = this.nTimeSteps;
 380         int length = this.fluctuations.length;
 381         if( ntimesteps > length ) {
 382             return false;
 383         }
 384         float[] flucts = this.fluctuations;
 385         float expectedreturnrate = this.expectedReturnRate;
 386         float vol = this.volatility;
 387         float dtime = this.dTime;
 388
 389         //
 390         // First, make use of the passed in seed value.
 391         MyRandom rnd;
 392         float v1,v2, r;
 393         v1 = (float)0.0;
 394         v2 = (float)0.0;
 395         if( randomSeed == -1 ) {
 396             rnd = new MyRandom(0, v1, v2);
 397         } else {
 398             rnd = new MyRandom((int)randomSeed, v1, v2);
 399         }
 400
 401         //
 402         // Determine the mean and standard-deviation, from the mean-drift and volatility.
 403         float mean = (expectedreturnrate-(float)0.5*vol*vol)*dtime;
 404         float sd   = vol*Math.sqrtf(dtime);
 405         float gauss, meanGauss=(float)0.0, variance=(float)0.0;
 406         for( int i=0; i < ntimesteps; i += 2 ) {
 407             r  = rnd.seed();
 408             gauss = r*rnd.v1;
 409             meanGauss+= gauss;
 410             variance+= gauss*gauss;
 411             //
 412             // Now map this onto a general Gaussian of given mean and variance.
 413             flucts[i] = mean + sd*gauss;
 414             //      dbgPrintln("gauss="+gauss+" fluctuations="+fluctuations[i]);
 415
 416             gauss  = r*rnd.v2;
 417             meanGauss+= gauss;
 418             variance+= gauss*gauss;
 419             //
 420             // Now map this onto a general Gaussian of given mean and variance.
 421             flucts[i+1] = mean + sd*gauss;
 422         }
 423         meanGauss/=(float)ntimesteps;
 424         variance /=(float)ntimesteps;
 425         //    dbgPrintln("meanGauss="+meanGauss+" variance="+variance);
 426     }
 427     /**
 428      * Method for calculating the sequence of fluctuations, based around
 429      * a Gaussian distribution of given mean and variance, as defined
 430      * in this class' instance variables.  Mapping from Gaussian
 431      * distribution of (0,1) to (mean-drift,volatility) is done via
 432      * Ito's lemma on the log of the stock price.  This overloaded method
 433      * is for when the random seed should be decided by the system.
 434      *
 435      * @exception DemoException thrown if there are any problems with
 436      *                          the computation.
 437      */
 438     public void computeFluctuationsGaussian() {
 439         computeFluctuationsGaussian((long)-1);
 440     }
 441     /**
 442      * Method for calculating the corresponding rate path, given the
 443      * fluctuations and starting rate value.
 444      *
 445      * @param startValue the starting value of the rate path, to be
 446      *                   updated with the precomputed fluctuations.
 447      * @exception DemoException thrown if there are any problems with
 448      *                          the computation.
 449      */
 450     public void computePathValue(float startValue) {
 451         float[] pathvalue = this.pathValue;
 452         float[] flucts = this.fluctuations;
 453         int length = this.nTimeSteps;
 454         pathvalue[0] = startValue;
 455         if( returnDefinition == 1 |
 456                 returnDefinition == 2) {
 457             for(int i=1; i < length; i++ ) {
 458                 //System.printI((int)(flucts[i] * 10000));
 459                 pathvalue[i] = pathvalue[i-1] * Math.expf(flucts[i]);
 460             }
 461         }
 462     }
 463 }