VarianceGammaProcess.java

/*
 * Class:        VarianceGammaProcess
 * Description:
 * Environment:  Java
 * Software:     SSJ
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author
 * @since        2004
 *
 *
 * 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 VarianceGammaProcess extends StochasticProcess {
 
   protected GammaProcess randomTime; // For the transformed time method
   protected BrownianMotion BM;
 
   protected double theta, sigma, nu;
 
   public VarianceGammaProcess() {
   }

   public VarianceGammaProcess(double s0, double theta, double sigma, double nu, RandomStream stream) {
      this(s0, new BrownianMotion(s0, theta, sigma, stream), new GammaProcess(0.0, 1.0, nu, stream));
   }

   public VarianceGammaProcess(double s0, BrownianMotion BM, GammaProcess Gamma) {
      this.BM = BM;
      Gamma.setParams(0.0, 1.0, Gamma.getNu()); // forces the average of the GammaProcess
      randomTime = Gamma; // to be 1.0 and the initial value to be 0.0
      setParams(s0, BM.getMu(), BM.getSigma(), Gamma.getNu());
   }

   public double nextObservation() {
      // We first generate w, then verify what its new counter value is
      // This is necessary to be general enough to handle bridge sampling
      double nextBM = BM.nextObservation(randomTime.nextObservation());
      observationIndex = BM.getCurrentObservationIndex();
      path[observationIndex] = nextBM;
      observationCounter++;
      return nextBM;
   }

   public double[] generatePath() {
      BM.setObservationTimes(randomTime.generatePath(), d);
      path = BM.generatePath();
      observationIndex = d;
      observationCounter = d;
      return path;
   }

   public double[] generatePath(double[] uniform01) {
      int dd = uniform01.length;
      int d = dd / 2;
 
      if (dd % 2 != 0) {
         throw new IllegalArgumentException("The Array uniform01 must have a even length");
      }
 
      double[] QMCpointsGP = new double[d];
      double[] QMCpointsBM = new double[d];
 
      for (int i = 0; i < d; i++) {
         QMCpointsGP[i] = uniform01[2 * i]; // the odd numbers for the gamma process
         QMCpointsBM[i] = uniform01[2 * i + 1]; // and the even for the BM process
      }
      BM.setObservationTimes(randomTime.generatePath(QMCpointsGP), d);
 
      path = BM.generatePath(QMCpointsBM);
      observationIndex = d;
      observationCounter = d;
      return path;
   }

   public void resetStartProcess() {
      observationIndex = 0;
      observationCounter = 0;
      BM.resetStartProcess();
      randomTime.resetStartProcess();
   }

   public void setParams(double s0, double theta, double sigma, double nu) {
      this.x0 = s0;
      this.theta = theta;
      this.sigma = sigma;
      this.nu = nu;
      if (observationTimesSet)
         init(); // Otherwise no need to.
   }

   public double getTheta() {
      return theta;
   }

   public double getSigma() {
      return sigma;
   }

   public double getNu() {
      return nu;
   }
 
   protected void init() {
      super.init();
      if (observationTimesSet) {
         randomTime.setObservationTimes(t, d);
         randomTime.x0 = t[0];
      }
   }

   public void setObservationTimes(double t[], int d) {
      super.setObservationTimes(t, d); // sets the observation times of the GammaProcess by
   } // calling init()

   public void setStream(RandomStream stream) {
      BM.setStream(stream);
   }

   public RandomStream getStream() {
      return BM.getStream();
   }

   public BrownianMotion getBrownianMotion() {
      return BM;
   }

   public GammaProcess getGammaProcess() {
      return randomTime;
   }
 
}