GeometricBrownianMotion.java

/*
 * Class:        GeometricBrownianMotion
 * Description:
 * 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.stochprocess;
 
import umontreal.ssj.rng.*;
import umontreal.ssj.probdist.*;
import umontreal.ssj.randvar.*;

public class GeometricBrownianMotion extends StochasticProcess {
 
   protected NormalGen gen;
   protected BrownianMotion bm; // The underlying BM process X.
   protected double mu, sigma;
   protected double[] mudt;

   public GeometricBrownianMotion(double s0, double mu, double sigma, RandomStream stream) {
      this(s0, mu, sigma, new BrownianMotion(0.0, 0.0, 1.0, stream));
   }

   public GeometricBrownianMotion(double s0, double mu, double sigma, BrownianMotion bm) {
      this.bm = bm;
      setParams(s0, mu, sigma);
   }
 
   public void setObservationTimes(double[] t, int d) {
      this.d = d;
      super.setObservationTimes(t, d);
      bm.setObservationTimes(t, d);
   }
 
   public double nextObservation() {
      // Note : this implementation is general, to deal with
      // the possibility of generating bm with bridge sampling, for example. ???
 
      double s = x0 * Math.exp(bm.nextObservation());
      observationIndex = bm.getCurrentObservationIndex();
      path[observationIndex] = s;
      // Could be different than simply 'observationCounter++' because of the
      // possibility of Brownian bridge
 
      return s;
   }
 
   public double[] generatePath() {
      path[0] = x0;
      bm.generatePath();
      for (int i = 1; i <= d; ++i)
         path[i] = x0 * Math.exp(bm.getObservation(i));
      observationCounter = d;
      return path;
   }
 
   public double[] generatePath(RandomStream stream) {
      setStream(stream);
      return generatePath();
   }

   public void resetStartProcess() {
      observationCounter = 0;
      bm.resetStartProcess();
   }

   public void setParams(double s0, double mu, double sigma) {
      this.x0 = s0;
      this.mu = mu;
      this.sigma = sigma;
      bm.setParams(0.0, mu - 0.5 * sigma * sigma, sigma);
      if (observationTimesSet)
         init(); // Otherwise not needed.
   }

   public void setStream(RandomStream stream) {
      (bm.gen).setStream(stream);
   }

   public RandomStream getStream() {
      return (bm.gen).getStream();
   }

   public double getMu() {
      return mu;
   }

   public double getSigma() {
      return sigma;
   }

   public NormalGen getGen() {
      return gen;
   }

   public BrownianMotion getBrownianMotion() {
      return bm;
   }
 
   protected void init() {
      super.init(); // Maybe useless...
   }
 
}