|
| int | getDimension () |
| | Returns the dimension (number of available coordinates) of the points. More...
|
| |
| int | getNumPoints () |
| | Returns the number of points. More...
|
| |
| abstract double | getCoordinate (int i, int j) |
| | Returns \(u_{i,j}\), the coordinate \(j\) of the point \(i\). More...
|
| |
| PointSetIterator | iterator () |
| | Constructs and returns a point set iterator. More...
|
| |
| void | randomize (PointSetRandomization rand) |
| | Randomizes this point set using the given rand. More...
|
| |
| void | addRandomShift (int d1, int d2, RandomStream stream) |
| | By default, this method generates a random shift in the protected double[] array shift, to be used eventually for a random shift modulo 1. More...
|
| |
| void | addRandomShift (RandomStream stream) |
| | Same as addRandomShift(0, dim, stream), where dim is the dimension of the point set. More...
|
| |
|
void | addRandomShift (int d1, int d2) |
| | Refreshes the random shift (generates new uniform values for the random shift coordinates) for coordinates d1 to d2-1, using the saved shiftStream.
|
| |
|
void | addRandomShift () |
| | Same as addRandomShift(0, dim), where dim is the dimension of the point set.
|
| |
|
void | clearRandomShift () |
| | Erases the current random shift, if any.
|
| |
| String | toString () |
| | Formats a string that contains information about the point set. More...
|
| |
| String | formatPoints () |
| | Same as invoking formatPoints(n, d) with \(n\) and \(d\) equal to the number of points and the dimension of this object, respectively. More...
|
| |
| String | formatPoints (int n, int d) |
| | Formats a string that displays the same information as returned by toString, together with the first \(d\) coordinates of the first \(n\) points. More...
|
| |
| String | formatPoints (PointSetIterator iter) |
| | Same as invoking formatPoints(iter, n, d) with \(n\) and \(d\) equal to the number of points and the dimension, respectively. More...
|
| |
| String | formatPoints (PointSetIterator iter, int n, int d) |
| | Same as invoking formatPoints(n, d), but prints the points by calling iter repeatedly. More...
|
| |
| String | formatPointsBase (int b) |
| | Similar to formatPoints(), but the points coordinates are printed in base \(b\). More...
|
| |
| String | formatPointsBase (int n, int d, int b) |
| | Similar to formatPoints(n, d), but the points coordinates are printed in base \(b\). More...
|
| |
| String | formatPointsBase (PointSetIterator iter, int b) |
| | Similar to formatPoints(iter), but the points coordinates are printed in base \(b\). More...
|
| |
| String | formatPointsBase (PointSetIterator iter, int n, int d, int b) |
| | Similar to formatPoints(iter, n, d), but the points coordinates are printed in base \(b\). More...
|
| |
| String | formatPointsNumbered () |
| | Same as invoking formatPointsNumbered(n, d) with \(n\) and \(d\) equal to the number of points and the dimension, respectively. More...
|
| |
| String | formatPointsNumbered (int n, int d) |
| | Same as invoking formatPoints(n,d), except that the points are numbered. More...
|
| |
This abstract class represents a general point set.
It defines some basic methods for accessing and manipulating the points and other properties of the point set. Conceptually, a point set can be viewed as a two-dimensional array, whose element \((i,j)\) contains \(u_{i,j}\), the coordinate \(j\) of point \(i\), for \(i\geq 0\) and \(j\geq 0\). Each coordinate \(u_{i,j}\) is assumed to be in the unit interval \([0,1]\). Whether the values 0 and 1 can occur or not may depend on the actual implementation of the point set. In general, when the points are randomized, after the randomization we add (internally, when the points or coordinates are requested) \(\epsilon/2\) to each coordinate for a very small \(\epsilon > 0\), so that 0 never occurs in the output. By default, in this PointSet class, we have \(\epsilon = 2^{-54}\).
All points have the same number of coordinates (their dimension) and this number can be queried by getDimension. The number of points is queried by getNumPoints. The points and coordinates are both numbered starting from 0 and their number can actually be infinite.
The iterator method provides a PointSetIterator object which can enumerate the points and their coordinates. Several iterators over the same point set can coexist at any given time. However, in the current implementation they will all enumerate the same randomized points when the points are randomized, because the randomizations are integrated in the point sets and not in the iterators. These iterators are instances of a hidden inner-class that implements the PointSetIterator interface. The default implementation of iterator provided here relies on the method getCoordinate to access the coordinates directly. However, this approach is rarely efficient. (One exception is in a CachedPointSet.) Specialized implementations that dramatically improve the performance are provided in subclasses of PointSet. The PointSetIterator interface actually extends the umontreal.ssj.rng.RandomStream interface, so that the iterator can also be seen as a umontreal.ssj.rng.RandomStream and used wherever such a stream is required for generating uniform random numbers. This permits one to easily replace pseudorandom numbers by the coordinates of a selected set of highly-uniform points, i.e., to replace Monte Carlo by QMC or RQMC in a simulation program.
The present abstract class has only one abstract method: getCoordinate. Providing an implementation for this method is already sufficient for the subclass to work. However, in most cases, efficiency can be dramatically improved by overwriting iterator to provide a custom iterator that does not necessarily rely on getCoordinate. Direct use of getCoordinate to access the coordinates is generally discouraged. One should access the points and coordinates via the iterators. Built-in range checks when generating the points require some extra time and also assume that nobody ever uses negative indices. If getCoordinate is never accessed directly by the user, it may be implemented without range checks.
In this abstract class, the addRandomShift() methods generate a double[] array to be used eventually to add a random shift modulo 1, but this random shift is not used here. It can be used in subclasses when generating coordinates.
In subclasses, addRandomShift (d1, d2, stream) can also be optionally re-implemented to produce something else than a double[] array, for example when we want the random shift to be digital. There are also some types of point sets that do not use at all such a random shift.
By default, this method generates a random shift in the protected double[] array shift, to be used eventually for a random shift modulo 1.
This random shift will be added (modulo 1) to all the points when they are enumerated by the iterator.
The random shift is generated using the stream to generate the uniform random numbers, one for each of the coordinates d1 to d2-1. The variable shiftStream is also set to this stream. Allowing an arbitrary range d1 to d2-1 permits one to extends the random shift to additional coordinates when needed, e.g., when the number of coordinates that we need is unknown a priori. There are also other situations in which we may want to randomize only specific coordinates, e.g., in the Array-RQMC method.
This method is re-implemented in subclasses for which a different form of shift is appropriate, e.g., should produce a random digital shift in base \(b\) for a #DigitalNet, a binary digital shift for a #DigitalNetBase2, etc.
These methods are used internally by randomizations. For example, calling RandomShift.randomize(PointSet) calls addRandomShift. Normally, one should not call them directly, but use #PointSetRandomization objects instead.
