DigitalNet.h File Reference

This file contains the base classes for digital nets in base 2. More...

#include "latbuilder/Util.h"
#include "netbuilder/Types.h"
#include "netbuilder/GeneratingMatrix.h"
#include "netbuilder/NetConstructionTraits.h"
#include <memory>
#include <sstream>
#include <stdexcept>

Classes
class	NetBuilder::AbstractDigitalNet
	Abstract class representing digital nets in base 2. More...
class	NetBuilder::DigitalNet< NC >
	Derived class of AbstractDigitalNet designed to implement specific construction methods. More...

Namespaces
namespace	NetBuilder
	NetBuilder namespace.

Detailed Description

This file contains the base classes for digital nets in base 2.

The high-level abstract representation of a digital net essentially corresponds to a vector of generating matrices. This representation is used to reason about digital nets whenever we do not need to actually construct them, e.g. to implement figures of merit that run computations based on the matrices. The AbstractDigitalNet class implements this representation.

Concrete implementations of digital nets rely on construction methods. A construction method is a way of specifying the subspace of nets which is of interest for us and how to construct nets from this subspace. We can be interested in exploring the whole space (which we called explicit construction, as we directly work on the generating matrices). But we can also be interested in exploring specific subspaces (such as Sobol nets, polynomial lattice rules), or even subspaces generated by applying randomizations to a base net.

A construction method is defined by choosing two main variables:

• the list of generating values, which are used to create each net of our subspace. There is one generating value for each coordinate of the net. Generating values are specific to each net, and these are the variables which get optimized when exploring the subspace.
• the size parameters, which are the parameters common to all nets which are needed by the construction rule. They are not optimized when exploring the subspace.

There are currently 4 construction methods implemented: Sobol, polynomial, explicit, and Left Matrix Scramble

• Sobol: the size parameter is the number of columns of the matrices, and the generating values are the direction numbers used to construct a given coordinate.
• Polynomial: the size parameter is the Polynomial modulus, and the generating value is the Polynomial used to construct a given coordinate.
• Explicit: the size parameter is the dimensions of the matrices, and the generating value is the matrix itself.
• Left Matrix Scramble: the size parameter is the base net, and the generating value is the scrambling matrix.

The DigitalNet class derives from AbstractDigitalNet, and contains methods common to all construction methods (such as extending the net by using a new generating value). It is templated by the NetConstruction class. This is the good level of abstraction in order to create tasks (e.g. search methods) on digital nets.

Finally, the NetConstructionTraits (in NetConstructionsTraits.h) enumerations contain, for each construction method, the functions that are specific to the construction method, the most important ones being:

• how to sample a random generating value.
• how to construct a generating matrix from a generating value.
• (in some cases) how to explore exhaustively the space of generating values.

This organization allows static polymorphism, while limiting the complexity of the code (in most instances, the AbstractDigitalNet class is the good level of abstraction, and it does not require templating).

Currently there are two types of FOMs for digital nets: FOMs based on t-value, and kernel based FOMs.

• The t-value based bounds use our algorithm to compute the t-value. Some of them are projection-dependent (ie we sum t-values on different projections).
• The kernel based FOMs are computed thanks to the Lattice Builder machinery (with Coordinate Uniform evaluation). The important property of these FOMs is that the kernel \(\omega\) is evaluated only on \(n\) different points, which are \({i/n, 0 <= i <= n}\). These \(n\) values are stored. Then computing the value of the FOM on a given projection amounts to clever (but simple) calculus on these $n$ values. The key point here is that on each coordinate, the point set is a permutation of \({i/n, 0 <= i <= n}\), which is called a "Stride" in Lattice Builder. This property is verified for general digital nets, as long as the generating matrices are square. The way to compute the Stride for digital nets is explained in more details in Section 4.3.2 of Maxime’s report (https://github.com/umontreal-simul/latnetbuilder/blob/dev/reports/report_godin.pdf), and implemented in latbuilder/Storage-SIMPLE-DIGITAL.h.