ArrayOfDoubleChains.java

package umontreal.ssj.markovchainrqmc;
 
import umontreal.ssj.stat.*;
import umontreal.ssj.rng.*;
import umontreal.ssj.hups.*;
import umontreal.ssj.util.*;
import umontreal.ssj.util.multidimsort.*;
 
import java.util.Arrays;

public class ArrayOfDoubleChains extends ArrayOfComparableChains {
 
   protected MarkovChainDouble baseChain; // Single object for all chains.
   protected double[] state; // States of the chains.
   protected double[] perfState; // performance mesure of the states

   public ArrayOfDoubleChains(MarkovChainDouble baseChain, PointSetRandomization rand) {
      super(baseChain, rand, new OneDimSort(0));
      this.baseChain = baseChain;
   }

   public ArrayOfDoubleChains(MarkovChainDouble baseChain) {
      this(baseChain, new RandomShift(new MRG32k3a()));
   }

   public void makeCopies(int n) {
      state = new double[n];
      perfState = new double[n];
      this.n = n;
   }

   public void setStatesDouble(double[] S) {
      if (S.length != n) {
         this.n = S.length;
         System.out.println("WARNING : number of chains modified" + " to fit size of S in setStatesDouble(S)");
      }
      for (int i = 0; i < n; i++) {
         state[i] = S[i];
      }
   }

   public double[] getStatesDouble() {
      return state;
   }

   public void initStatesDouble() {
      Arrays.fill(state, baseChain.initialStateDouble());
      Arrays.fill(perfState, 0.0);
   }

   public boolean simulOneStepArrayRQMC(int step, PointSet p) {
      boolean allStopped = true;
      p.randomize(randomization); // Randomize point set.
      PointSetIterator stream = p.iterator();
      stream.resetStartStream(); // Beginning of point set.
      for (int i = 0; i < n; i++) {
         if (state[i] == Double.POSITIVE_INFINITY)
            continue;
         state[i] = baseChain.nextStepDouble(step, state[i], stream);
         stream.resetNextSubstream();
         if (state[i] == Double.POSITIVE_INFINITY) {
            perfState[i] = baseChain.getPerformance();
         } else
            perfState[i] = baseChain.getPerformanceDouble(state[i], step);
         allStopped = allStopped && state[i] == Double.POSITIVE_INFINITY;
      }
      return allStopped;
   }

   public double simulArrayRQMC(PointSet p, int numSteps) {
      boolean allStopped = false;
      initStatesDouble();
 
      for (int step = 0; step < numSteps && !allStopped; step++) {
         sortChains();
         allStopped = simulOneStepArrayRQMC(step, p);
      }
      return calcMeanPerf();
   }

   public double calcMeanPerf() {
      double sumPerf = 0.0; // Sum of performances.
      for (int i = 0; i < n; ++i) {
         sumPerf += perfState[i];
      }
      return sumPerf / n;
   }

   public void sortChains() {
      Arrays.sort(state);
   }

   public String toString() {
      StringBuffer sb = new StringBuffer(baseChain.toString());
      sb.append("***************************************************************" + PrintfFormat.NEWLINE);
      for (int i = 0; i < n; ++i)
         sb.append(" ; " + PrintfFormat.g(15, 6, state[i]));
      sb.append("PrintfFormat.NEWLINE");
      return sb.toString();
   }
}