This class provides the basic structures for storing and manipulating linear digital nets in base \(b\), for an arbitrary base \(b\ge2\). More...

Inheritance diagram for umontreal.ssj.hups.DigitalNet:

Classes
class	DigitalNetIterator
class	DigitalNetIteratorNoGray

Public Member Functions
	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.
String	toString ()
	Formats a string that contains information on this digital net.
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 provides the basic structures for storing and manipulating linear digital nets in base \(b\), for an arbitrary base \(b\ge2\).

We recall that a net contains \(n = b^k\) points in \(s\) dimensions, where the \(i\)th point \(\mathbf{u}_i\), for \(i=0,…,b^k-1\), is defined as follows:

\begin{align*} i & = \sum_{\ell=0}^{k-1} a_{i,\ell} b^{\ell}, \\ \begin{pmatrix} u_{i,j,1} \\ u_{i,j,2} \\ \vdots \end{pmatrix} & = \mathbf{C}_j \begin{pmatrix} a_{i,0} \\ a_{i,1} \\ \vdots \\ a_{i,k-1} \end{pmatrix} , \\ u_{i,j} & = \sum_{\ell=1}^{\infty}u_{i,j,\ell} b^{-\ell}, \\ \mathbf{u}_i & = (u_{i,0},\dots,u_{i,s-1}). \end{align*}

In our implementation, the matrices \(\mathbf{C}_j\) are \(r\times k\), so the expansion of \(u_{i,j}\) is truncated to its first \(r\) terms. The points are stored implicitly by storing the generator matrices \(\mathbf{C}_j\) in a large two-dimensional array of integers, with \(srk\) elements. For general \(b\), the element \((l,c)\) of \(\mathbf{C}_j\) (counting elements from 0) is stored at position \([jk+c][l]\) in this array.

To enumerate the points, one should avoid using the method getCoordinate(i, j) for arbitrary values of i and j, because this is much slower than using a PointSetIterator to access successive coordinates. By default, the iterator enumerates the points \(\mathbf{u}_i\) using a Gray code technique as proposed in [rANT79a], [221], and also described in [67], [84]). With this technique, the \(b\)-ary representation of \(i\), \(\mathbf{a}_i = (a_{i,0}, …, a_{i,k-1})\), is replaced in Equation (digital-Cj) by a Gray code representation of \(i\), \(\mathbf{g}_i = (g_{i,0}, …, g_{i,k-1})\). The Gray code \(\mathbf{g}_i\) used here is defined by \(g_{i,k-1} = a_{i,k-1}\) and \(g_{i,\ell} = (a_{i,\ell} - a_{i,\ell+1}) \bmod b\) for \(\ell= 0,…,k-2\). It has the property that \(\mathbf{g}_i = (g_{i,0}, …, g_{i,k-1})\) and \(\mathbf{g}_{i+1} = (g_{i+1,0}, …, g_{i+1,k-1})\) differ only in the position of the smallest index \(\ell\) such that \(a_{i,\ell} < b - 1\), and we have \(g_{i+1,\ell} = (g_{i,\ell}+1) \bmod b\) in that position. This Gray code representation permits a more efficient enumeration of the points by the iterators. It changes the order in which the points \(\mathbf{u}_i\) are enumerated, but the first \(b^m\) points remain the same for every integer \(m\). The \(i\)th point of the sequence with the Gray enumeration is the \(i’\)th point of the original enumeration, where \(i’\) is the integer whose \(b\)-ary representation \(\mathbf{a}_{i’}\) is given by the Gray code \(\mathbf{g}_i\). To enumerate all the points successively, we never need to compute the Gray codes explicitly. It suffices to know the position \(\ell\) of the Gray code digit that changes at each step, and this can be found quickly from the \(b\)-ary representation \(\mathbf{a}_i\). The digits of each coordinate \(j\) of the current point can be updated by adding column \(\ell\) of the generator matrix \(\mathbf{C}_j\) to the old digits, modulo \(b\).

Digital nets can be randomized in various ways [174], [58], [121], [189]. Several types of randomizations specialized for nets are implemented directly in this class. A simple but important randomization is the random digital shift in base \(b\), defined as follows: replace each digit \(u_{i,j,\ell}\) in ( digital-uij ) by \((u_{i,j,\ell} + d_{j,\ell}) \bmod b\), where the \(d_{j,\ell}\)’s are i.i.d. uniform over \(\{0,\dots,b-1\}\). This is equivalent to applying a single random shift to all the points in a formal series representation of their coordinates [121], [157]. In practice, the digital shift is truncated to \(w\) digits, for some integer \(w\ge r\). Applying a digital shift does not change the equidistribution and \((t,m,s)\)-net properties of a point set [84], [119], [157]. Moreover, with the random shift, each point has the uniform distribution over the unit hypercube (but the points are not independent, of course).

A second class of randomizations specialized for digital nets are the linear matrix scrambles [174], [58], [84], [189], which multiply the matrices \(\mathbf{C}_j\) by a random invertible matrix \(\mathbf{M}_j\), modulo \(b\). There are several variants, depending on how \(\mathbf{M}_j\) is generated, and on whether \(\mathbf{C}_j\) is multiplied on the left or on the right. In our implementation, the linear matrix scrambles are incorporated directly into the matrices \(\mathbf{C}_j\) (as in [84]), so they do not slow down the enumeration of points. Methods are available for applying linear matrix scrambles and for removing these randomizations. These methods generate the appropriate random numbers and make the corresponding changes to the \(\mathbf{C}_j\)’s. A copy of the original \(\mathbf{C}_j\)’s is maintained, so the point set can be returned to its original unscrambled state at any time. When a new linear matrix scramble is applied, it is always applied to the original generator matrices. The method resetGeneratorMatrices removes the current matrix scramble by resetting the generator matrices to their original state. On the other hand, the method eraseOriginalGeneratorMatrices replaces the original generator matrices by the current ones, making the changes permanent. This could be useful if one wishes to apply two or more linear matrix scrambles on top of each other and not retain the original matrices.

With the linear matrix scrambles alone, the randomized points do not have the uniform distribution over the unit cube. For this reason, they are usually combined with a random digital shift; this combination is called an affine matrix scramble [189]. These two randomizations are applied via separate methods. The linear matrix scrambles are incorporated into the matrices \(\mathbf{C}_j\) whereas the digital random shift is stored and applied separately, independently of the other scrambles.

Applying a digital shift or a linear matrix scramble to a digital net invalidates all current iterators for the current point, because each iterator uses a cached copy of the current point, which is updated only when the current point index of that iterator changes, and the update also depends on the cached copy of the previous point. After applying any kind of scrambling or randomization that affects the DigitalNet object, the iterators must be reinitialized to the initial point by invoking PointSetIterator.resetCurPointIndex or re-instantiated by the iterator method (this is not done automatically).

Definition at line 138 of file DigitalNet.java.

Constructor & Destructor Documentation

◆ DigitalNet()

umontreal.ssj.hups.DigitalNet.DigitalNet ( )

Empty constructor.

Definition at line 196 of file DigitalNet.java.

Member Function Documentation

◆ addRandomShift() [1/2]

void umontreal.ssj.hups.DigitalNet.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.

The dimension of the current shift is reset to d2 and the current streamShift is set to stream. This shift vector \((d_{j,0},…,d_{j,k-1})\) is generated uniformly over \(\{0,\dots,b-1\}^k\) for each coordinate. This shift vector will be added modulo \(b\) to the digits of all the points by any iterator on this point set. After adding a digital shift, all iterators must be reconstructed or reset to zero.

Parameters

stream random number stream used to generate the uniforms

Reimplemented from umontreal.ssj.hups.PointSet.

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 310 of file DigitalNet.java.

◆ addRandomShift() [2/2]

void umontreal.ssj.hups.DigitalNet.addRandomShift ( RandomStream stream )

Same as addRandomShift(0, dim, stream), where dim is the dimension of the digital net.

Parameters

stream random number stream used to generate the uniforms

Reimplemented from umontreal.ssj.hups.PointSet.

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 342 of file DigitalNet.java.

◆ clearRandomShift()

void umontreal.ssj.hups.DigitalNet.clearRandomShift ( )

Erases the current digital random shift, if any.

Reimplemented from umontreal.ssj.hups.PointSet.

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 349 of file DigitalNet.java.

◆ eraseOriginalGeneratorMatrices()

void umontreal.ssj.hups.DigitalNet.eraseOriginalGeneratorMatrices ( )

Erases the original generator matrices and replaces them by the current ones.

The current linear matrix scrambles thus become permanent. This is useful if we want to apply several scrambles in succession to a given digital net.

Definition at line 905 of file DigitalNet.java.

◆ getCoordinate()

double umontreal.ssj.hups.DigitalNet.getCoordinate	(	int	i,
		int	j )

Returns \(u_{i',j}\), the coordinate \(j\) of point \(i'\), where \(i'\) is the Gray code for \(i\).

Parameters

i	point index, to be transformed to a Gray code
j	coordinate index

Returns: the value of \(u_{i,j}\)

Reimplemented from umontreal.ssj.hups.PointSet.

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 221 of file DigitalNet.java.

◆ getCoordinateNoGray()

double umontreal.ssj.hups.DigitalNet.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).

Parameters

i	point index
j	coordinate index

Returns: the value of \(u_{i,j}\)

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 261 of file DigitalNet.java.

◆ getInterlacing()

int umontreal.ssj.hups.DigitalNet.getInterlacing ( )

Returns the interlacing factor.

Definition at line 202 of file DigitalNet.java.

◆ iBinomialMatrixScramble()

void umontreal.ssj.hups.DigitalNet.iBinomialMatrixScramble ( RandomStream stream )

Applies the \(i\)-binomial matrix scramble proposed by Tezuka.

[219] (see also [189] ). This multiplies each \(\mathbf{C}_j\) on the left by a \(w\times w\) nonsingular lower-triangular matrix \(\mathbf{M}_j\) as in leftMatrixScramble, but with the additional constraint that all entries on any given diagonal or subdiagonal of \(\mathbf{M}_j\) are identical.

Parameters

stream random number stream used as generator of the randomness

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 647 of file DigitalNet.java.

◆ iBinomialMatrixScrambleFaurePermut()

void umontreal.ssj.hups.DigitalNet.iBinomialMatrixScrambleFaurePermut	(	RandomStream	stream,
		int	sb )

Similar to iBinomialMatrixScramble except that the diagonal elements of each matrix \(\mathbf{M}_j\) are chosen as in leftMatrixScrambleFaurePermut.

Parameters

stream	random number stream used to generate the randomness
sb	Only the first \(sb\) elements of \(F\) are used

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 733 of file DigitalNet.java.

◆ iBinomialMatrixScrambleFaurePermutAll()

void umontreal.ssj.hups.DigitalNet.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.

Parameters

stream	random number stream used to generate the randomness
sb	Only the first \(sb\) elements of \(F\) are used

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 756 of file DigitalNet.java.

◆ iBinomialMatrixScrambleFaurePermutDiag()

void umontreal.ssj.hups.DigitalNet.iBinomialMatrixScrambleFaurePermutDiag	(	RandomStream	stream,
		int	sb )

Similar to iBinomialMatrixScrambleFaurePermut except that all the off-diagonal elements are 0.

Parameters

stream	random number stream used to generate the randomness
sb	Only the first \(sb\) elements of \(F\) are used

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 744 of file DigitalNet.java.

◆ iterator()

PointSetIterator umontreal.ssj.hups.DigitalNet.iterator ( )

Returns: an iterator to this point set, using the Gray code enumeration.

Reimplemented from umontreal.ssj.hups.PointSet.

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 249 of file DigitalNet.java.

◆ iteratorNoGray()

PointSetIterator umontreal.ssj.hups.DigitalNet.iteratorNoGray ( )

Returns an iterator that does not use the Gray code.

With this one, the points will be enumerated in the order of their first coordinate before randomization.

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 294 of file DigitalNet.java.

◆ leftMatrixScramble()

void umontreal.ssj.hups.DigitalNet.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.

\(\mathbf{M}_j\), as suggested by Matoušek [174] and implemented by Hong and Hickernell [84] . The diagonal entries of each matrix \(\mathbf{M}_j\) are generated uniformly over \(\{1,…,b-1\}\), the entries below the diagonal are generated uniformly over \(\{0,…,b-1\}\), and all these entries are generated independently. This means that in base \(b=2\), all diagonal elements are equal to 1.

Remarks: Richard: Les matrices de leftMatrixScramble sont carrées et triangulaires inférieures. PL pense qu’il faut considérer la possibilité de rajouter des lignes à ces matrices pour pouvoir randomiser plus les derniers chiffres ou les derniers bits.

Parameters

stream random number stream used to generate the randomness

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 487 of file DigitalNet.java.

◆ leftMatrixScrambleDiag()

void umontreal.ssj.hups.DigitalNet.leftMatrixScrambleDiag ( RandomStream stream )

Similar to leftMatrixScramble except that all the off-diagonal elements of the \(\mathbf{M}_j\) are 0.

In base b=2, M_j must be the identity, so this scramble does nothing!

Parameters

stream random number stream used to generate the randomness

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 522 of file DigitalNet.java.

◆ leftMatrixScrambleFaurePermut()

void umontreal.ssj.hups.DigitalNet.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] .

They are generated uniformly over the first sb elements of array \(F\), where \(F\) is made up of a permutation of the integers \([1..(b-1)]\). These integers are sorted by increasing order of the upper bounds of the extreme discrepancy for the given integer.

Parameters

stream	random number stream used to generate the randomness
sb	Only the first \(sb\) elements of \(F\) are used

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 610 of file DigitalNet.java.

◆ leftMatrixScrambleFaurePermutAll()

void umontreal.ssj.hups.DigitalNet.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.

Parameters

stream	random number stream used to generate the randomness
sb	Only the first \(sb\) elements of \(F\) are used

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 633 of file DigitalNet.java.

◆ leftMatrixScrambleFaurePermutDiag()

void umontreal.ssj.hups.DigitalNet.leftMatrixScrambleFaurePermutDiag	(	RandomStream	stream,
		int	sb )

Similar to leftMatrixScrambleFaurePermut except that all off-diagonal elements are 0.

Parameters

stream	random number stream used to generate the randomness
sb	Only the first \(sb\) elements of \(F\) are used

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 621 of file DigitalNet.java.

◆ printGeneratorMatrices()

void umontreal.ssj.hups.DigitalNet.printGeneratorMatrices ( int s )

Prints the generator matrices in standard form for dimensions 1 to \(s\).

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 912 of file DigitalNet.java.

◆ resetGeneratorMatrices()

void umontreal.ssj.hups.DigitalNet.resetGeneratorMatrices ( )

Restores the original generator matrices.

This removes the current linear matrix scrambles.

Definition at line 893 of file DigitalNet.java.

◆ rightMatrixScramble()

void umontreal.ssj.hups.DigitalNet.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.

[58] (see also [84] ). The diagonal entries of the matrix \(\mathbf{M}\) are generated uniformly over \(\{1,…,b-1\}\), the entries above the diagonal are generated uniformly over \(\{0,…,b-1\}\), and all the entries are generated independently. The effect of this scramble is only to change the order in which the points are generated. If one computes the average value of a function over all the points of a given digital net, or over a number of points that is a power of the basis, then this scramble makes no difference.

Parameters

stream random number stream used as generator of the randomness

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 855 of file DigitalNet.java.

◆ setInterlacing()

void umontreal.ssj.hups.DigitalNet.setInterlacing ( int interlacing )

Sets the interlacing factor.

Definition at line 209 of file DigitalNet.java.

◆ stripedMatrixScramble()

void umontreal.ssj.hups.DigitalNet.stripedMatrixScramble ( RandomStream stream )

Applies the striped matrix scramble proposed by Owen.

[189] . It multiplies each \(\mathbf{C}_j\) on the left by a \(w\times w\) nonsingular lower-triangular matrix \(\mathbf{M}_j\) as in leftMatrixScramble, but with the additional constraint that in any column, all entries below the diagonal are equal to the diagonal entry, which is generated randomly over \(\{1,…,b-1\}\). Note that for \(b=2\), the matrices \(\mathbf{M}_j\) become deterministic, with all entries on and below the diagonal equal to 1.

Parameters

stream random number stream used as generator of the randomness

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 774 of file DigitalNet.java.

◆ stripedMatrixScrambleFaurePermutAll()

void umontreal.ssj.hups.DigitalNet.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.

Parameters

stream	random number stream used as generator of the randomness
sb	Only the first \(sb\) elements of \(F\) are used

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 809 of file DigitalNet.java.

◆ toString()

String umontreal.ssj.hups.DigitalNet.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.PointSet.

Reimplemented in umontreal.ssj.hups.DigitalNetBase2, umontreal.ssj.hups.DigitalNetBase2FromFile, umontreal.ssj.hups.DigitalNetFromFile, umontreal.ssj.hups.F2wNetLFSR, umontreal.ssj.hups.F2wNetPolyLCG, umontreal.ssj.hups.FaureSequence, umontreal.ssj.hups.NiedSequenceBase2, umontreal.ssj.hups.NiedXingSequenceBase2, and umontreal.ssj.hups.SobolSequence.

Definition at line 359 of file DigitalNet.java.

◆ unrandomize()

void umontreal.ssj.hups.DigitalNet.unrandomize ( )

Restores the original generator matrices and removes the random shift.

Reimplemented in umontreal.ssj.hups.DigitalNetBase2.

Definition at line 884 of file DigitalNet.java.

The documentation for this class was generated from the following file:

src/main/java/umontreal/ssj/hups/DigitalNet.java

SSJ API Documentation Stochastic Simulation in Java

Classes

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DigitalNet()

Member Function Documentation

◆ addRandomShift() [1/2]

◆ addRandomShift() [2/2]

◆ clearRandomShift()

◆ eraseOriginalGeneratorMatrices()

◆ getCoordinate()

◆ getCoordinateNoGray()

◆ getInterlacing()

◆ iBinomialMatrixScramble()

◆ iBinomialMatrixScrambleFaurePermut()

◆ iBinomialMatrixScrambleFaurePermutAll()

◆ iBinomialMatrixScrambleFaurePermutDiag()

◆ iterator()

◆ iteratorNoGray()

◆ leftMatrixScramble()

◆ leftMatrixScrambleDiag()

◆ leftMatrixScrambleFaurePermut()

◆ leftMatrixScrambleFaurePermutAll()

◆ leftMatrixScrambleFaurePermutDiag()

◆ printGeneratorMatrices()

◆ resetGeneratorMatrices()

◆ rightMatrixScramble()

◆ setInterlacing()

◆ stripedMatrixScramble()

◆ stripedMatrixScrambleFaurePermutAll()

◆ toString()

◆ unrandomize()