PointSet.java

/*
 * Class:        PointSet
 * Description:  Base class of all point sets
 * 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.hups;
 
import java.util.NoSuchElementException;
import umontreal.ssj.rng.RandomStream;
import umontreal.ssj.util.Num;
import umontreal.ssj.util.PrintfFormat;

public abstract class PointSet {

   protected static final int MAXBITS = 31; // Max number of usable bits.

   protected double EpsilonHalf = 1.0 / Num.TWOEXP[55]; // 2^{-55}

   protected int dim = 0;

   protected int numPoints = 0;

   // **Pierre:** Maybe this could be defined only in `CycleBasedPointSet` ???
   protected int dimShift = 0;

   protected int capacityShift = 0;

   protected double[] shift;

   protected RandomStream shiftStream;

   public int getDimension() {
      return dim;
   }

   public int getNumPoints() {
      return numPoints;
   }

   public static int getMaxBits() {
      return MAXBITS;
   }

   public abstract double getCoordinate(int i, int j);

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

   // @Deprecated
   public void randomize(PointSetRandomization rand) {
      rand.randomize(this);
      // Note that RandomShift.randomize(p) calls addRandomShift !
   }

   public void addRandomShift(int d1, int d2, RandomStream stream) {
      if (d1 < 0 || d1 > d2)
         throw new IllegalArgumentException("illegal parameter d1 or d2");
      if (d2 > capacityShift) {
         int d3 = Math.max(4, capacityShift);
         while (d2 > d3)
            d3 *= 2;
         double[] temp = new double[d3];
         capacityShift = d3;
         for (int i = 0; i < d1; i++)
            temp[i] = shift[i];
         shift = temp;
      }
      shiftStream = stream;
      dimShift = d2;
      for (int i = d1; i < d2; i++)
         shift[i] = shiftStream.nextDouble();
   }

   public void addRandomShift(RandomStream stream) {
      addRandomShift(0, dim, stream);
   }

   public void addRandomShift(int d1, int d2) {
      addRandomShift(d1, d2, shiftStream);
   }

   public void addRandomShift() {
      addRandomShift(0, dim);
   }

   public void clearRandomShift() {
      capacityShift = 0;
      dimShift = 0;
//      shiftStream = null;
   }

   public String toString() {
      StringBuffer sb = new StringBuffer("Number of points: ");
      int x = getNumPoints();
      if (x == Integer.MAX_VALUE)
         sb.append("infinite");
      else
         sb.append(x);
      sb.append(PrintfFormat.NEWLINE + "Point set dimension: ");
      x = getDimension();
      if (x == Integer.MAX_VALUE)
         sb.append("infinite");
      else
         sb.append(x);
      return sb.toString();
   }

   public String formatPoints() {
      PointSetIterator iter = iterator();
      return formatPoints(iter);
   }

   public String formatPoints(int n, int d) {
      PointSetIterator iter = iterator();
      return formatPoints(iter, n, d);
   }

   public String formatPoints(PointSetIterator iter) {
      int n = getNumPoints();
      if (n == Integer.MAX_VALUE)
         throw new UnsupportedOperationException("Number of points is infinite");
      int d = getDimension();
      if (d == Integer.MAX_VALUE)
         throw new UnsupportedOperationException("Dimension is infinite");
      return formatPoints(iter, n, d);
   }

   public String formatPoints(PointSetIterator iter, int n, int d) {
      if (getNumPoints() < n)
         n = getNumPoints();
      if (getDimension() < d)
         d = getDimension();
      StringBuffer sb = new StringBuffer(toString());
      sb.append(PrintfFormat.NEWLINE + PrintfFormat.NEWLINE + "Points of the point set:" + PrintfFormat.NEWLINE);
      for (int i = 0; i < n; i++) {
         for (int j = 0; j < d; j++) {
            sb.append("  ");
            sb.append(iter.nextCoordinate());
         }
         sb.append(PrintfFormat.NEWLINE);
         iter.resetToNextPoint();
      }
      return sb.toString();
   }

   public String formatPointsBase(int b) {
      PointSetIterator iter = iterator();
      return formatPointsBase(iter, b);
   }

   public String formatPointsBase(int n, int d, int b) {
      PointSetIterator iter = iterator();
      return formatPointsBase(iter, n, d, b);
   }

   public String formatPointsBase(PointSetIterator iter, int b) {
      int n = getNumPoints();
      if (n == Integer.MAX_VALUE)
         throw new UnsupportedOperationException("Number of points is infinite");
      int d = getDimension();
      if (d == Integer.MAX_VALUE)
         throw new UnsupportedOperationException("Dimension is infinite");
      return formatPointsBase(iter, n, d, b);
   }

   public String formatPointsBase(PointSetIterator iter, int n, int d, int b) {
      if (getNumPoints() < n)
         n = getNumPoints();
      if (getDimension() < d)
         d = getDimension();
      StringBuffer sb = new StringBuffer(toString());
      sb.append(PrintfFormat.NEWLINE + PrintfFormat.NEWLINE + "Points of the point set:" + PrintfFormat.NEWLINE);
      double x;
      int acc = 10;
      if (b == 2)
         acc = 20;
      else if (b == 3)
         acc = 13;
      else
         acc = 10;
      int width = acc + 3;
      String chaine;
      for (int i = 0; i < n; i++) {
         for (int j = 0; j < d; j++) {
            sb.append("  ");
            x = iter.nextCoordinate();
            chaine = PrintfFormat.formatBase(-width, acc, b, x);
            sb.append(chaine);
         }
         sb.append(PrintfFormat.NEWLINE);
         iter.resetToNextPoint();
      }
      return sb.toString();
   }

   public String formatPointsNumbered() {
      int n = getNumPoints();
      if (n == Integer.MAX_VALUE)
         throw new UnsupportedOperationException("Number of points is infinite");
      int d = getDimension();
      if (d == Integer.MAX_VALUE)
         throw new UnsupportedOperationException("Dimension is infinite");
      return formatPointsNumbered(n, d);
   }

   public String formatPointsNumbered(int n, int d) {
      if (getNumPoints() < n)
         n = getNumPoints();
      if (getDimension() < d)
         d = getDimension();
      StringBuffer sb = new StringBuffer(toString());
      PointSetIterator itr = iterator();
      sb.append(PrintfFormat.NEWLINE + PrintfFormat.NEWLINE + "Points of the point set:");
      for (int i = 0; i < n; i++) {
         sb.append(PrintfFormat.NEWLINE + "Point " +
         // itr.getCurPointIndex() + " = (");
               i + "  =  (");
         boolean first = true;
         for (int j = 0; j < d; j++) {
            if (first)
               first = false;
            else
               sb.append(", ");
            sb.append(itr.nextCoordinate());
         }
         sb.append(")");
         itr.resetToNextPoint();
      }
      return sb.toString();
   }
 
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   protected class DefaultPointSetIterator implements PointSetIterator {

      protected int curPointIndex = 0;

      protected int curCoordIndex = 0;

      protected double EpsilonHalf = 1.0 / Num.TWOEXP[55];

      protected void outOfBounds() {
         if (getCurPointIndex() >= numPoints)
            throw new NoSuchElementException("Not enough points available");
         else
            throw new NoSuchElementException("Not enough coordinates available");
      }

      public void setCurCoordIndex(int j) {
         curCoordIndex = j;
      }

      public void resetCurCoordIndex() {
         setCurCoordIndex(0);
      }

      public int getCurCoordIndex() {
         return curCoordIndex;
      }

      public boolean hasNextCoordinate() {
         return getCurCoordIndex() < getDimension();
      }

      public double nextCoordinate() {
         if (getCurPointIndex() >= numPoints || getCurCoordIndex() >= dim)
            outOfBounds();
         return getCoordinate(curPointIndex, curCoordIndex++);
      }

      public void nextCoordinates(double p[], int d) {
         if (getCurCoordIndex() + d > getDimension())
            outOfBounds();
         for (int j = 0; j < d; j++)
            p[j] = nextCoordinate();
      }

      // This is called with i = numPoints when nextPoint generates the
      // last point, so i = numPoints must be allowed.
      // The "no more point" error will be raised if we ask for
      // a new coordinate or point when i = numPoints.
      public void setCurPointIndex(int i) {
         curPointIndex = i;
         resetCurCoordIndex();
      }

      public void resetCurPointIndex() {
         setCurPointIndex(0);
      }

      public int resetToNextPoint() {
         setCurPointIndex(curPointIndex + 1);
         return curPointIndex;
      }

      public int getCurPointIndex() {
         return curPointIndex;
      }

      public boolean hasNextPoint() {
         return getCurPointIndex() < getNumPoints();
      }

      public int nextPoint(double p[], int fromDim, int d) {
         setCurCoordIndex(fromDim);
         nextCoordinates(p, d);
         return resetToNextPoint();
      }

      public int nextPoint(double p[], int d) {
         resetCurCoordIndex();
         nextCoordinates(p, d);
         return resetToNextPoint();
      }

      public void resetStartStream() {
         resetCurPointIndex();
      }

      public void resetStartSubstream() {
         resetCurCoordIndex();
      }

      public void resetNextSubstream() { // Same as resetToNextPoint();
         resetToNextPoint();
      }

      public void setAntithetic(boolean b) {
         throw new UnsupportedOperationException();
      }

      public double nextDouble() {
         return nextCoordinate();
      }

      public void nextArrayOfDouble(double[] u, int start, int n) {
         if (n < 0)
            throw new IllegalArgumentException("n must be positive.");
         for (int i = start; i < start + n; i++)
            u[i] = nextDouble();
      }

      public int nextInt(int i, int j) {
         return (i + (int) (nextDouble() * (j - i + 1.0)));
      }

      public void nextArrayOfInt(int i, int j, int[] u, int start, int n) {
         if (n < 0)
            throw new IllegalArgumentException("n must be positive.");
         for (int k = start; k < start + n; k++)
            u[k] = nextInt(i, j);
      }

      public String formatState() {
         return "Current point index: " + getCurPointIndex() + PrintfFormat.NEWLINE + "Current coordinate index: "
               + getCurCoordIndex();
      }
   }
}