StochasticProcess.java

/*
 * Class:        StochasticProcess
 * Description:  Base class for all stochastic processes
 * 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.RandomStream;

 
public abstract class StochasticProcess {
 
   protected boolean observationTimesSet = false; // Used in some subclasses
   // to make sure 'setObservationTimes' has been invoked before calling 'init'.
 
   protected double x0 = 0.0; // Default Initial Value of the process
   protected int d = -1; // Number of observation times
   protected int observationIndex = 0; // Index of last generated obs. time
   protected int observationCounter = 0; // Counts how many observations have
   // been generated so far. Useful when they are not generated in
   // chronological order.
   protected double[] t; // Observation times
   protected double[] path; // Observations of the process (skeleton).
   // protected RandomStream stream; // Random stream used to generate the process
   protected int[] observationIndexFromCounter; // Links counter# to index#

   public void setObservationTimes(double[] T, int d) {
      if (d <= 0)
         throw new IllegalArgumentException("Number of observation times d <= 0");
      this.d = d;
      observationTimesSet = true;
 
      // Copy of the observation times
      this.t = new double[d + 1];
      System.arraycopy(T, 0, this.t, 0, d + 1);
 
      // Test chronological order
      for (int i = 0; i < d; i++) {
         if (T[i + 1] < T[i])
            throw new IllegalArgumentException("Observation times T[] are not time-ordered");
      }
 
      // Construction of 'path' object
      // We do not do it in 'init()' because we do not want to change the
      // path object if the user only calls 'setParams'
      path = new double[d + 1];
 
      // Process-specific initialization; usually precomputes quantities
      // that depend on the observation times.
      init();
   }

   public void setObservationTimes(double delta, int d) {
      t = new double[d + 1];
      for (int i = 0; i <= d; i++)
         t[i] = i * delta;
      setObservationTimes(t, d);
   }

   public double[] getObservationTimes() {
      return t;
   }

   public int getNumObservationTimes() {
      return d;
   }

   public abstract double[] generatePath();

   public double[] generatePath(RandomStream stream) {
      setStream(stream);
      return generatePath();
   }

   public double[] getPath() {
      return path;
   }

   public void getSubpath(double[] subpath, int[] pathIndices) {
      for (int j = 0; j < subpath.length; j++) {
         subpath[j] = path[pathIndices[j]];
      }
   }

   public double getObservation(int j) {
      return path[j];
   }

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

   public boolean hasNextObservation() {
      if (observationCounter < d)
         return true;
      else
         return false;
   }

   public double nextObservation() {
      throw new UnsupportedOperationException("Method not defined in this class");
   }

   public int getCurrentObservationIndex() {
      return observationIndex;
   }

   public double getCurrentObservation() {
      return path[observationIndex];
   }

   public double getX0() {
      return x0;
   }

   public void setX0(double s0) {
      x0 = s0;
      init();
   }

   public abstract void setStream(RandomStream stream);

   public abstract RandomStream getStream();
 
   /***
    * Called by 'setObservationTimes' to initialize arrays and precompute constants
    * to speed up execution. See overriding method 'init' in subclasses for details
    ***/
   protected void init() {
      if (observationTimesSet) // If observation times are not defined, do nothing.
         path[0] = x0;
      // We do this here because the s0 parameter may have changed through
      // a call to the 'setParams' method.
   }

   public int[] getArrayMappingCounterToIndex() {
      return observationIndexFromCounter;
   }
 
}