MultivariateStochasticProcess.java

/*
 * Class:        MultivariateStochasticProcess
 * Description:  
 * Environment:  Java
 * Software:     SSJ 
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author       
 * @since
 
 * SSJ is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License (GPL) as published by the
 * Free Software Foundation, either version 3 of the License, or
 * any later version.
 
 * SSJ is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 
 * A copy of the GNU General Public License is available at
   <a href="http://www.gnu.org/licenses">GPL licence site</a>.
 */
package umontreal.ssj.stochprocess;

public abstract class MultivariateStochasticProcess extends StochasticProcess {
 
   protected double[] x0;  // Default value of the process at time t_0.
   protected int c = 1;    // Dimension of the process.

   public abstract double[] generatePath();

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

   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 ordered chronologically");
      }
 
      /***
       * Process specific initialization; usually precomputes quantities that depend
       * on the observation times.
       ***/
      init();
   }

   public void getObservation(int j, double[] obs) {
      for (int i = 0; i < c; i++)
         obs[i] = path[c * j + i];
   }

   public double getObservation(int j, int i) {
      return path[c * j + i];
   }

   public abstract void nextObservationVector(double[] obs);

   public void getCurrentObservation(double[] obs) {
      for (int i = 0; i < c; i++)
         obs[i] = path[c * observationIndex + i];
   }

   public double[] getX0(double[] x0) {
      for (int i = 0; i < c; i++)
         x0[i] = this.x0[i];
      return x0;
   }
 
   protected void init() {
      if (observationTimesSet)
         createPath();
      if (path != null) // If observation times are not defined, do nothing.
         for (int i = 0; i < c; i++)
            path[i] = x0[i];
   }
 
   /*** Called by 'init' to create new path ***/
   protected void createPath() {
      path = new double[c * (d + 1)];
   }

   public int getDimension() {
      return c;
   }
 
}