GeometricLevyProcess.java

/*
 * Class:        GeometricLevyProcess
 * 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.*;

public abstract class GeometricLevyProcess extends StochasticProcess {
 
   protected StochasticProcess levyProcess;
   protected double omegaRiskNeutralCorrection;
   protected double muGeom; // usually the interest rate
   protected double[] muGeomRNdt; // risk neutral corrected
   protected double[] muGeomRNdT; // risk neutral corrected, from time t0.
 
   protected void init() {
      super.init();
      if (observationTimesSet) {
         // Telling the g\'eom\'etric process about the observation times
         levyProcess.setObservationTimes(t, d);
 
         // We need to know in which order the observations are generated
         this.observationIndexFromCounter = levyProcess.getArrayMappingCounterToIndex();
 
         muGeomRNdt = new double[d];
         for (int i = 0; i < d; i++) {
            muGeomRNdt[i] = (muGeom - omegaRiskNeutralCorrection) * (t[i + 1] - t[i]);
         }
         muGeomRNdT = new double[d + 1];
         for (int i = 0; i <= d; i++) {
            muGeomRNdT[i] = (muGeom - omegaRiskNeutralCorrection) * (t[i] - t[0]);
         }
      }
   }

   public double[] generatePath() {
      double s = x0;
      resetStartProcess();
      double[] arithmPath = levyProcess.generatePath();
      for (int i = 0; i < d; i++) {
         s *= Math.exp(muGeomRNdt[i] + arithmPath[i + 1] - arithmPath[i]);
         path[i + 1] = s;
      }
      observationIndex = d;
      return path;
   }

   public double nextObservation() {
      double levy = levyProcess.nextObservation();
      observationIndex = levyProcess.getCurrentObservationIndex();
      path[observationIndex] = x0 * Math.exp(muGeomRNdT[observationIndex] + levy);
      return path[observationIndex];
   }

   public void resetStartProcess() {
      super.init();
      levyProcess.resetStartProcess();
   }

   public void setObservationTimes(double[] time, int d) {
      super.setObservationTimes(time, d);
      levyProcess.setObservationTimes(time, d);
   }

   public double getOmega() {
      return omegaRiskNeutralCorrection;
   }

   public double getMuGeom() {
      return muGeom;
   }

   public void setMuGeom(double muGeom) {
      this.muGeom = muGeom;
   }

   public StochasticProcess getLevyProcess() {
      return levyProcess;
   }

   public void resetRiskNeutralCorrection(double omegaRN) {
      omegaRiskNeutralCorrection = omegaRN;
      init();
   }

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

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