KorobovLatticeSequence.java

/*
 * Class:        KorobovLatticeSequence
 * Description:  
 * 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;

public class KorobovLatticeSequence extends KorobovLattice {
   int base; // Base for radical inversion
   int inverse; // global variables for radical inverssion,
   int n; // since bloody JAVA cannot pass references
 
   // Method modPower is inherited from Rank1Lattice.

   public KorobovLatticeSequence(int b, int a) {
// Pas termine: ne fonctionne pas
      super(2, 3, 1);
      if (a < 1)
         throw new IllegalArgumentException("KorobovLatticeSequence:   Multiplier a must be >= 1");
//      dim       = Integer.MAX_VALUE;
//      numPoints = Integer.MAX_VALUE;
      base = b;
      throw new UnsupportedOperationException("NOT FINISHED");
   }
 
   // A very inefficient way of generating the points!
   public double getCoordinate(int i, int j) {
      int n;
      int inverse;
      if (i == 0)
         return 0.0;
      else if (j == 0)
         return radicalInverse(base, i);
      else {
         // integerRadicalInverse (i);
         n = 1;
         for (inverse = 0; i > 0; i /= base) {
            inverse = inverse * base + (i % base);
            n *= base;
         }
         return (double) ((inverse * modPower(genA, j, n)) % n) / (double) n;
      }
   }
 
   // ... has been unrolled in getCoordinate.
   private void integerRadicalInverse(int i) {
      // Attention: returns results in variables n and inverse.
      n = 1;
      for (inverse = 0; i > 0; i /= base) {
         inverse = inverse * base + (i % base);
         n *= base;
      }
   }
 
}