CachedPointSet.java

/*
 * Class:        CachedPointSet
 * Description:
 * Environment:  Java
 * Software:     SSJ
 * Copyright (C) 2001--2018  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.hups;
 
import umontreal.ssj.util.PrintfFormat;
import java.util.Arrays;
import umontreal.ssj.util.multidimsort.DoubleArrayComparator;
import umontreal.ssj.util.multidimsort.MultiDimSort;
import umontreal.ssj.rng.RandomStream;

public class CachedPointSet extends PointSet {
   protected PointSet P; // Original PointSet which is cached in the present object.
   protected double x[][]; // Cached points.
   int fromPoint = 0; // Number of skipped points (usually 0).
   int fromDim = 0; // Number of skipped coordinates (usually 0).
   // int numPoints; // Number of retained points, inherited from PointSet.
   // int dim; // Dimension of the *retained* points, inherited from PointSet.
   boolean randomizeParent = true;
 
   protected CachedPointSet() {
   } // Constructs an empty cache for a point set.

   public CachedPointSet(PointSet p, int fromPoint, int toPoint, int fromDim, int toDim) {
      if (p.getNumPoints() < toPoint - fromPoint)
         throw new IllegalArgumentException("Cannot cache more points than in point set p.");
      if (p.getDimension() < toDim - fromDim)
         throw new IllegalArgumentException("Attempt to cache points using more coordinates than the dimension.");
      if (toPoint == Integer.MAX_VALUE)
         throw new IllegalArgumentException("Cannot cache infinite number of points");
      if (toDim == Integer.MAX_VALUE)
         throw new IllegalArgumentException("Cannot cache infinite dimensional points");
      this.fromPoint = fromPoint;
      numPoints = toPoint - fromPoint;
      this.fromDim = fromDim;
      dim = toDim - fromDim;
      this.P = p;
      x = new double[numPoints][dim];
      fillCache(fromDim, dim);
   }

   protected void fillCache(int fromDim, int dim) {
      PointSetIterator itr = P.iterator();
      if (fromPoint > 0)
         itr.setCurPointIndex(fromPoint);
      for (int i = 0; i < numPoints; i++)
         itr.nextPoint(x[i], fromDim, dim);
   }

   public CachedPointSet(PointSet p, int n, int dim) {
      this(p, 0, n, 0, dim);
   }

   public CachedPointSet(PointSet p) {
      this(p, 0, p.getNumPoints(), 0, p.getDimension());
   }

   public PointSetIterator iterator() {
      return new CachedPointSetIterator();
   }

   public void setRandomizeParent(boolean randomizeParent) {
      this.randomizeParent = randomizeParent;
   }

   public void addRandomShift(int d1, int d2, RandomStream stream) {
      P.addRandomShift(d1, d2, stream);
      fillCache(fromDim, dim);
   }

   public void randomize(PointSetRandomization rand) {
      if (randomizeParent) {
         rand.randomize(P);
         fillCache(fromDim, dim);
      } else {
         rand.randomize(this);
      }
   }

   public void sortByCoordinate(int j) {
      Arrays.sort(x, new DoubleArrayComparator(j));
   }

   public <T> void sort(MultiDimSort<T> sort) {
      sort.sort(x);
      // sort.sort (P); init(); ? No.
   }

   public void stripCoordinates(int d) {
      for (int i = 0; i < numPoints; i++)
         for (int j = 0; j < d; j++)
            x[i][j] = x[i][j + d];
      dim = dim - d;
   }
 
   public String toString() {
      StringBuffer sb = new StringBuffer("Cached point set" + PrintfFormat.NEWLINE);
      sb.append(super.toString());
      sb.append(PrintfFormat.NEWLINE + "Cached point set information {" + PrintfFormat.NEWLINE);
      sb.append(P.toString());
      sb.append(PrintfFormat.NEWLINE + "}");
      return sb.toString();
   }
 
   public double getCoordinate(int i, int j) {
      return x[i][j];
   }
 
   public double[][] getArray() {
      return x;
   }

   public PointSet getParentPointSet() {
      return P;
   }
 
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 

   protected class CachedPointSetIterator extends DefaultPointSetIterator {
 
      public double nextCoordinate() {
         if (getCurPointIndex() >= numPoints || getCurCoordIndex() >= dim)
            outOfBounds();
         return x[curPointIndex][curCoordIndex++];
      }
 
      public void nextCoordinates(double p[], int d) {
         if (getCurCoordIndex() + d > getDimension())
            outOfBounds();
         for (int j = 0; j < d; j++)
            p[j] = x[curPointIndex][curCoordIndex++];
      }
 
   }
 
}