This class implements digital nets or digital sequences formed by the first \(n = b^k\) points of the Faure sequence in base \(b\). More...
Public Member Functions | |
| FaureSequence (int b, int k, int r, int w, int dim) | |
| Constructs a digital net in base \(b\), with \(n = b^k\) points and \(w\) output digits, in dim dimensions. | |
| FaureSequence (int n, int dim) | |
Same as FaureSequence(b, k, w, w, dim) with base \(b\) equal to the smallest prime larger or equal to dim, and with at least n points. | |
| String | toString () |
| Formats a string that contains information on this digital net. | |
| void | extendSequence (int k) |
| Increases the number of points to \(n = b^k\) from now on. | |
| Public Member Functions inherited from umontreal.ssj.hups.DigitalSequence | |
| DigitalNet | toNet () |
| Transforms this digital sequence into a digital net without changing the coordinates of the points. | |
| DigitalNet | toNetShiftCj () |
| Transforms this digital sequence into a digital net by adding one dimension and shifting all coordinates by one position. | |
| PointSetIterator | iteratorShift () |
| Similar to iterator, except that the first coordinate of the points is \(i/n\), the second coordinate is obtained via the generating matrix \(\mathbf{C}_0\), the next one via. | |
| PointSetIterator | iteratorShiftNoGray () |
| This iterator shifts all coordinates of each point one position to the right and sets the first coordinate of point \(i\) to. | |
| Public Member Functions inherited from umontreal.ssj.hups.DigitalNet | |
| DigitalNet () | |
| Empty constructor. | |
| int | getInterlacing () |
| Returns the interlacing factor. | |
| void | setInterlacing (int interlacing) |
| Sets the interlacing factor. | |
| double | getCoordinate (int i, int j) |
| Returns \(u_{i',j}\), the coordinate \(j\) of point \(i'\), where \(i'\) is the Gray code for \(i\). | |
| PointSetIterator | iterator () |
| double | getCoordinateNoGray (int i, int j) |
| Returns \(u_{i,j}\), the coordinate \(j\) of point \(i\), the points being enumerated in the standard order (no Gray code). | |
| PointSetIterator | iteratorNoGray () |
| Returns an iterator that does not use the Gray code. | |
| void | addRandomShift (int d1, int d2, RandomStream stream) |
| Generates a random digital shift for coordinates \(j\) from d1 to d2-1, using stream to generate the random numbers. | |
| void | addRandomShift (RandomStream stream) |
Same as addRandomShift(0, dim, stream), where dim is the dimension of the digital net. | |
| void | clearRandomShift () |
| Erases the current digital random shift, if any. | |
| void | leftMatrixScramble (RandomStream stream) |
| Applies a linear scramble by multiplying each \(\mathbf{C}_j\) on the left by a \(w\times w\) nonsingular lower-triangular matrix. | |
| void | leftMatrixScrambleDiag (RandomStream stream) |
| Similar to leftMatrixScramble except that all the off-diagonal elements of the \(\mathbf{M}_j\) are 0. | |
| void | leftMatrixScrambleFaurePermut (RandomStream stream, int sb) |
| Similar to leftMatrixScramble except that the diagonal elements of each matrix \(\mathbf{M}_j\) are chosen from a restricted set of the best integers as calculated by Faure [58] . | |
| void | leftMatrixScrambleFaurePermutDiag (RandomStream stream, int sb) |
| Similar to leftMatrixScrambleFaurePermut except that all off-diagonal elements are 0. | |
| void | leftMatrixScrambleFaurePermutAll (RandomStream stream, int sb) |
| Similar to leftMatrixScrambleFaurePermut except that the elements under the diagonal are also chosen from the same restricted set as the diagonal elements. | |
| void | iBinomialMatrixScramble (RandomStream stream) |
| Applies the \(i\)-binomial matrix scramble proposed by Tezuka. | |
| void | iBinomialMatrixScrambleFaurePermut (RandomStream stream, int sb) |
| Similar to iBinomialMatrixScramble except that the diagonal elements of each matrix \(\mathbf{M}_j\) are chosen as in leftMatrixScrambleFaurePermut. | |
| void | iBinomialMatrixScrambleFaurePermutDiag (RandomStream stream, int sb) |
| Similar to iBinomialMatrixScrambleFaurePermut except that all the off-diagonal elements are 0. | |
| void | iBinomialMatrixScrambleFaurePermutAll (RandomStream stream, int sb) |
| Similar to iBinomialMatrixScrambleFaurePermut except that the elements under the diagonal are also chosen from the same restricted set as the diagonal elements. | |
| void | stripedMatrixScramble (RandomStream stream) |
| Applies the striped matrix scramble proposed by Owen. | |
| void | stripedMatrixScrambleFaurePermutAll (RandomStream stream, int sb) |
| Similar to stripedMatrixScramble except that the elements on and under the diagonal of each matrix \(\mathbf{M}_j\) are chosen as in leftMatrixScrambleFaurePermut. | |
| void | rightMatrixScramble (RandomStream stream) |
| Applies a linear scramble by multiplying each \(\mathbf{C}_j\) on the right by a single \(k\times k\) nonsingular upper-triangular matrix \(\mathbf{M}\), as suggested by Faure and Tezuka. | |
| void | unrandomize () |
| Restores the original generator matrices and removes the random shift. | |
| void | resetGeneratorMatrices () |
| Restores the original generator matrices. | |
| void | eraseOriginalGeneratorMatrices () |
| Erases the original generator matrices and replaces them by the current ones. | |
| void | printGeneratorMatrices (int s) |
| Prints the generator matrices in standard form for dimensions 1 to \(s\). | |
| Public Member Functions inherited from umontreal.ssj.hups.PointSet | |
| int | getDimension () |
| Returns the dimension (number of available coordinates) of the points. | |
| int | getNumPoints () |
| Returns the number of points. | |
| void | randomize (PointSetRandomization rand) |
| Randomizes this point set using the given rand. | |
| 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. | |
| 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. | |
| 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. | |
| 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. | |
| String | formatPoints (PointSetIterator iter, int n, int d) |
Same as invoking formatPoints(n, d), but prints the points by calling iter repeatedly. | |
| String | formatPointsBase (int b) |
Similar to formatPoints(), but the points coordinates are printed in base \(b\). | |
| String | formatPointsBase (int n, int d, int b) |
Similar to formatPoints(n, d), but the points coordinates are printed in base \(b\). | |
| String | formatPointsBase (PointSetIterator iter, int b) |
Similar to formatPoints(iter), but the points coordinates are printed in base. | |
| 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\). | |
| String | formatPointsNumbered () |
Same as invoking formatPointsNumbered(n, d) with \(n\) and \(d\) equal to the number of points and the dimension, respectively. | |
| String | formatPointsNumbered (int n, int d) |
Same as invoking formatPoints(n,d), except that the points are numbered. | |
Additional Inherited Members | |
| Static Public Member Functions inherited from umontreal.ssj.hups.PointSet | |
| static int | getMaxBits () |
| Returns the maximum number of usable bits. | |
| Protected Attributes inherited from umontreal.ssj.hups.PointSet | |
| double | EpsilonHalf = 1.0 / Num.TWOEXP[55] |
| To avoid 0 for nextCoordinate when random shifting, we add this to each coordinate. | |
| int | dim = 0 |
| Dimension of the points. | |
| int | numPoints = 0 |
| Number of points. | |
| int | dimShift = 0 |
| Current dimension of the shift. | |
| int | capacityShift = 0 |
| Number of array elements in the shift vector, always >= dimShift. | |
| double[] | shift |
| This is the shift vector as a double[] array, which contains the current random shift in case we apply a random shift modulo 1. | |
| RandomStream | shiftStream |
| Stream used to generate the random shifts. | |
| Static Protected Attributes inherited from umontreal.ssj.hups.PointSet | |
| static final int | MAXBITS = 31 |
| Since Java has no unsigned type, the 32nd bit cannot be used efficiently, so we have only 31 bits. | |
Detailed Description
This class implements digital nets or digital sequences formed by the first \(n = b^k\) points of the Faure sequence in base \(b\).
Values of \(n\) up to \(2^{31}\) are allowed. One has \(r = k\). The generator matrices are
\[ \mathbf{C}_j = \mathbf{P}^j \mod b \]
for \(j=0,…,s-1\), where \(\mathbf{P}\) is a \(k\times k\) upper triangular matrix whose entry \((l,c)\) is the number of combinations of
\(l\) objects among \(c\), \({c\choose l}\), for \(l\le c\) and is 0 for \(l > c\). The matrix \(\mathbf{C}_0\) is the identity, \(\mathbf{C}_1 = \mathbf{P}\), and the other \(\mathbf{C}_j\)’s can be defined recursively via \(\mathbf{C}_j = \mathbf{P} \mathbf{C}_{j-1} \mod b\). Our implementation uses the recursion
\[ {c \choose l} = {{c-1} \choose l} + {{c-1} \choose{l-1}} \]
to evaluate the binomial coefficients in the matrices \(\mathbf{C}_j\), as suggested by Fox [rFOX86a] (see also [67] , page 301). The entries \(x_{j,l,c}\) of \(\mathbf{C}_j\) are computed as follows:
\[ \begin{array}{lcll} x_{j,c,c} & = & 1 & \quad\mbox{ for } c=0,…,k-1, \\ x_{j,0,c} & = & j x_{j,0,c-1} & \quad\mbox{ for } c=1,…,k-1, \\ x_{j,l,c} & = & x_{j,l-1,c-1} + j x_{j,l,c-1} & \quad\mbox{ for } 2\le c < l \le k-1, \\ x_{j,l,c} & = & 0 & \quad\mbox{ for } c>l \mbox{ or } l \ge k. \end{array} \]
For any integer \(m > 0\) and \(\nu\ge0\), if we look at the vector \((u_{i,j,1},…,u_{i,j,m})\) (the first \(m\) digits of coordinate \(j\) of the output) when \(i\) goes from \(\nu b^m\) to \((\nu+1)b^m - 1\), this vector takes each of its \(b^m\) possible values exactly once. In particular, for \(\nu= 0\), \(u_{i,j}\) visits each value in the set \(\{0, 1/b^m, 2/b^m, …, (b^m-1)/b^m\}\) exactly once, so all one-dimensional projections of the point set are identical. However, the values are visited in a different order for the different values of \(j\) (otherwise all coordinates would be identical). For \(j=0\), they are visited in the same order as in the van der Corput sequence in base \(b\).
An important property of Faure nets is that for any integers \(m > 0\) and \(\nu\ge0\), the point set \(\{\mathbf{u}_i\) for \(i = \nu b^m,…, (\nu+1)b^m -1\}\) is a \((0,m,s)\)-net in base \(b\). In particular, for \(n = b^k\), the first \(n\) points form a \((0,k,s)\)-net in base \(b\). The Faure nets are also projection-regular and dimension-stationary (see [121] for definitions of these properties).
To obtain digital nets from the generalized Faure sequence [221] , where \(\mathbf{P}_j\) is left-multiplied by some invertible matrix \(\mathbf{A}_j\), it suffices to apply an appropriate matrix scramble (e.g., via leftMatrixScramble ). This changes the order in which \(u_{i,j}\) visits its different values, for each coordinate \(j\), but does not change the set of values that are visited. The \((0,m,s)\)-net property stated above remains valid.
<div class="SSJ-bigskip"></div><div class=
"SSJ-bigskip"></div>
Definition at line 89 of file FaureSequence.java.
Constructor & Destructor Documentation
◆ FaureSequence() [1/2]
| umontreal.ssj.hups.FaureSequence.FaureSequence | ( | int | b, |
| int | k, | ||
| int | r, | ||
| int | w, | ||
| int | dim ) |
Constructs a digital net in base \(b\), with \(n = b^k\) points and \(w\) output digits, in dim dimensions.
The points are the first \(n\) points of the Faure sequence. The generator matrices
\(\mathbf{C}_j\) are \(r\times k\). Unless, one plans to apply a randomization on more than \(k\) digits (e.g., a random digital shift for \(w > k\) digits, or a linear scramble yielding \(r > k\) digits), one should take \(w = r = k\) for better computational efficiency. Restrictions: dim \(\le500\) and \(b^k \le2^{31}\).
- Parameters
-
b base k there will be b^k points r number of rows in the generator matrices w number of output digits dim dimension of the point set
Definition at line 115 of file FaureSequence.java.
◆ FaureSequence() [2/2]
| umontreal.ssj.hups.FaureSequence.FaureSequence | ( | int | n, |
| int | dim ) |
Same as FaureSequence(b, k, w, w, dim) with base \(b\) equal to the smallest prime larger or equal to dim, and with at least n points.
The values of \(k\),
\(r\), and \(w\) are taken as \(k = \lceil\log_b n\rceil\) and \(r = w = \max(k, \lfloor30 / \log_2 b\rfloor)\).
- Parameters
-
n minimal number of points dim dimension of the point set
Definition at line 160 of file FaureSequence.java.
Member Function Documentation
◆ extendSequence()
| void umontreal.ssj.hups.FaureSequence.extendSequence | ( | int | k | ) |
Increases the number of points to \(n = b^k\) from now on.
- Parameters
-
k there will be b^k points
Reimplemented from umontreal.ssj.hups.DigitalSequence.
Definition at line 177 of file FaureSequence.java.
◆ toString()
| String umontreal.ssj.hups.FaureSequence.toString | ( | ) |
Formats a string that contains information on this digital net.
- Returns
- string representation of basic information on this digital net
Reimplemented from umontreal.ssj.hups.DigitalNet.
Definition at line 171 of file FaureSequence.java.
The documentation for this class was generated from the following file:
- src/main/java/umontreal/ssj/hups/FaureSequence.java
