VarianceGammaProcessDiff.java

/*
 * Class:        VarianceGammaProcessDiff
 * 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 VarianceGammaProcessDiff extends VarianceGammaProcess {
   protected GammaProcess gpos;
   protected GammaProcess gneg;
   protected double mup, mun, nup, nun;

   public VarianceGammaProcessDiff(double s0, double theta, double sigma, double nu, RandomStream stream) {
      this(s0, theta, sigma, nu, new GammaProcess(0.0, 1.0, 1.0, stream), new GammaProcess(0.0, 1.0, 1.0, stream));
      // Params mu, nu of the 2 gamma processes are redefined in init()
      // which will be called after a call to 'setObservTimes'
   }

   public VarianceGammaProcessDiff(double s0, double theta, double sigma, double nu, GammaProcess gpos,
         GammaProcess gneg) {
      this.gpos = gpos;
      this.gneg = gneg;
      setParams(s0, theta, sigma, nu);
      gneg.setStream(gpos.getStream()); // to avoid confusion with stream because there is only
      // one stream in the other constructor
   }
 
   public double nextObservation() {
      // This implementation takes possible bridge sampling into account
      double s = x0 + gpos.nextObservation() - gneg.nextObservation();
      observationIndex = gpos.getCurrentObservationIndex();
      path[observationIndex] = s;
      observationCounter++;
      return s;
   }
 
// no longer useful, this method was created to automaticaly alternate
// between the two processes the uniform random variables used in the
// in the simulation.  However, this method does not work if the two
// GammaProcess are PCA...
//    public double[] generatePath()  {
//         gpos.resetStartProcess();
//         gneg.resetStartProcess();
//         double s;
//         for (int i=1; i<=d; i++) {
//            s = x0 + gpos.nextObservation() - gneg.nextObservation();
//            path[gpos.getCurrentObservationIndex()] = s;
//            // Note: we must get the observCounter from gpos in the case that
//            // the process is generated by a Gamma bridge
//            // The observCounter of gneg should be the same because both
//            // gamma processes should be generated the same way
//         }
//         observationIndex   = d;
//         observationCounter = d;
//         return path;
//     }

   public double[] generatePath() {
      double[] pathUP = gpos.generatePath();
      double[] pathDOWN = gneg.generatePath();
 
      for (int i = 0; i < d; i++) {
         path[i + 1] = x0 + pathUP[i + 1] - pathDOWN[i + 1];
      }
      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[] QMCpointsUP = new double[d];
      double[] QMCpointsDW = new double[d];
 
      for (int i = 0; i < d; i++) {
         QMCpointsUP[i] = uniform01[2 * i]; // keeps the odd numbers for the gamma process
         QMCpointsDW[i] = uniform01[2 * i + 1]; // and the even for the BM process
      }
      gpos.resetStartProcess();
      gneg.resetStartProcess();
 
      double[] pathUP = gpos.generatePath(QMCpointsUP);
      double[] pathDOWN = gneg.generatePath(QMCpointsDW);
 
      for (int i = 0; i < d; i++) {
         path[i + 1] = x0 + pathUP[i + 1] - pathDOWN[i + 1];
      }
      observationIndex = d;
      observationCounter = d;
      return path;
   }

   public void resetStartProcess() {
      observationIndex = 0;
      observationCounter = 0;
      gpos.resetStartProcess();
      gneg.resetStartProcess();
   }

   public GammaProcess getGpos() {
      return gpos;
   }

   public GammaProcess getGneg() {
      return gneg;
   }
 
   protected void init() {
      // super.init() is not called because the init() in VarianceGammaProcess
      // is very different.
      mup = 0.5 * (Math.sqrt(theta * theta + 2 * sigma * sigma / nu) + theta);
      mun = 0.5 * (Math.sqrt(theta * theta + 2 * sigma * sigma / nu) - theta);
      nup = mup * mup * nu;
      nun = mun * mun * nu;
      if (observationTimesSet) {
         path[0] = x0;
         gpos.setParams(t[0], mup, nup);
         gneg.setParams(t[0], mun, nun);
      }
   }

   public void setObservationTimes(double t[], int d) {
      gpos.setObservationTimes(t, d);
      gneg.setObservationTimes(t, d);
      super.setObservationTimes(t, d);
// the initial value is set to t[0] in the init, which is called in
// super.setObservationTimes(t, d).
   }

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

   public void setStream(RandomStream stream) {
      gpos.setStream(stream);
      gneg.setStream(stream);
   }
 
}