An Efficient Quasi-Monte Carlo Algorithm for High Dimensional Numerical Integration

Abstract

In this paper, we develop a fast numerical algorithm, termed MDI-LR, for the efficient implementation of quasi-Monte Carlo lattice rules in computing d-dimensional integrals of a given function. The algorithm is based on converting the underlying lattice rule into a tensor-product form through an affine transformation, and further improving computational efficiency by incorporating a multilevel dimension iteration (MDI) strategy. This approach computes the function evaluations at the integration points collectively and iterates along each transformed coordinate direction, allowing substantial reuse of computations. As a result, the algorithm avoids the need to explicitly store integration points or compute function values at those points independently. Extensive numerical experiments are conducted to evaluate the performance of MDI-LR and compare it with the straightforward implementation of quasi-Monte Carlo lattice rules. The results demonstrate that MDI-LR achieves a computational complexity of order $O\left(N^2{d}^3\right)$ or better, where N denotes the number of points in each transformed coordinate direction. Thus, MDI-LR effectively mitigates the curse of dimensionality and revitalizes the use of QMC lattice rules for high dimensional integration.

1. Introduction

Numerical integration is an essential tool and building block in many scientific and engineering fields which requires to evaluate or estimate integrals of given (explicitly or implicitly) functions, which becomes very challenging in high dimensions due to the so-called the curse of dimensionality (CoD). They are seen in evaluating quantities of stochastic interests, solving high dimensional partial differential equations, or computing value functions of an option of a basket of securities. The goal of this paper is to develop and test an efficient algorithm based on quasi-Monte Carlo methods for evaluating the d-dimensional integral:

$$I_d\left(f\right):={\int }_{\Omega }f\left(\mathbf{x}\right)d\mathbf{x}$$

(1)

for a given function $f:\Omega :={[0,1]}^d\to \mathbf{R}$ and $d>>1$.

Classical numerical integration methods, such as tensor product and sparse grid methods [1,2] as well as Monte Carlo (MC) methods [3,4] require the evaluation of a function at a set of integration points. The computational complexity of the first two types of methods grows exponentially with the dimension d in the problem (i.e., the CoD), which limits their practical usage. Monte Carlo (MC) methods are often the default methods for high dimensional integration problems due to their ability of handling complicated functions and mitigating the CoD. We recall that the MC method approximates the integral by randomly sampling points within the integration domain and averaging their function values. The classical MC method has the following form:

$$Q_{n,d}\left(f\right)={\displaystyle \frac{1}{n}}\sum _{i=0}^{n-1}f\left({\mathbf{x}}_i\right),$$

(2)

where ${\left\{{\mathbf{x}}_i\right\}}_{i=0}^{n-1}$ denotes independent and uniformly distributed random samples in the integration domain $\Omega$. The expected error for the MC method is proportional to ${\displaystyle \frac{\sigma \left(f\right)}{\sqrt{n}}}$, where $\sigma {\left(f\right)}^2$ stands for the variance of f. If f is square-integrable then the expected error in (2) has the order $O(n^{-{\displaystyle \frac{1}{2}}})$ (note that the convergence rate is independent of the dimension d). Evidently, the MC method is simple and easy to implement, making them a popular choice for many applications. However, the MC method is slow to converge [5,6], especially for high dimensional problems, and the accuracy of the approximation depends on the number of random samples. One way to improve the convergence rate of the Monte Carlo method is to use quasi-Monte Carlo methods [7,8].

Quasi-Monte Carlo (QMC) methods [9,10] employ integration techniques that use point sets with better distribution properties than random sampling. Similar to the MC method, the QMC method also has the general form (2), but, unlike the MC method, the integration points ${\left\{{\mathbf{x}}_i\right\}}_{i=0}^{n-1}\in \Omega$ are chosen deterministically and methodically. The deterministic nature of the QMC method could lead to guaranteed error bounds and that the convergence rate could be faster than the $O(n^{-{\displaystyle \frac{1}{2}}})$ order of the MC method for sufficiently smooth functions. QMC error bounds are typically given in the form of Koksma-Hlawka-type inequalities as follows:

$$|I_d\left(f\right)-Q_{n,d}\left(f\right)|\le D({\mathbf{x}}_0,{\mathbf{x}}_1,\cdots ,{\mathbf{x}}_{n-1})V\left(f\right),$$

(3)

where $D({\mathbf{x}}_0,{\mathbf{x}}_1,\cdots ,{\mathbf{x}}_{n-1})$ is a (positive) discrepancy function which measures the non-uniformity of the point set ${\left\{{\mathbf{x}}_i\right\}}_{i=0}^{n-1}$ and $V\left(f\right)$ is a (positive) functional which measures the variability of f. Error bounds of this type separate the dependence on the cubature points from the dependence on the integrand. The QMC point sets with discrepancy of order $O\left(n^{-1}{(logn)}^d\right)$ or better are collectively known as low-discrepancy point sets [11].

One of the most popular QMC methods is the lattice rule, whose integration points are chosen to have a lattice structure, low-discrepancy, and better distribution properties than random sampling [12,13,14], hence, resulting in a more accurate method with faster convergence rate. However, traditional lattice rules still have limitations when applied to high dimensional problems. Good lattice rules almost always involve searching (cf. [15,16]), the cost of an exhaustive search (for n fixed) grows exponentially with the dimension d. Moreover, like the MC method, the number of integration points required to achieve a reasonable accuracy also increases exponentially with the dimension d (i.e., the CoD phenomenon), which makes the method computationally infeasible for very high dimensional integration problems.

Recent advances in quasi-Monte Carlo (QMC) methods have substantially extended their applicability and efficiency in high-dimensional numerical integration. In the past few years, researchers have developed various forms of randomized QMC (RQMC), adaptive transformation, and hybridization techniques that integrate ideas from importance sampling, stochastic optimization, and even machine learning-inspired transport mappings. For instance, Guth and Kaarnioja [17] applied QMC techniques to partial differential equations with generalized Gaussian input uncertainty, demonstrating that properly designed low-discrepancy sampling can substantially reduce variance in high-dimensional PDE solvers. Wang and Wang [18] analyzed the convergence rate of QMC with importance sampling in reproducing kernel Hilbert spaces (RKHS), providing new theoretical insights for unbounded functions. Melnikov and Milz [19] explored RQMC in the context of risk-averse stochastic optimization, confirming its superior performance in variance reduction and robustness. In financial modeling, Hok and Kucherenko [20] demonstrated the “unreasonable effectiveness” of RQMC for option pricing and risk analysis, achieving remarkable accuracy improvements over traditional Monte Carlo approaches. Furthermore, Imai, Kuo, and Owen [21] proposed a dimension-reduction-enhanced RQMC method that significantly reduces the effective dimension in high-dimensional integrals. Collectively, these recent studies highlight a clear trend toward the hybridization of adaptive transformations, dimension reduction, and randomized QMC techniques, which resonates with the motivation and design philosophy of the present work. Nevertheless, despite these promising developments, most existing QMC variants still face intrinsic challenges when tackling extremely high-dimensional problems—particularly those with dimensions exceeding one hundred—where convergence rates deteriorate rapidly and computational costs remain prohibitive.

To overcome the limitations of QMC lattice rules, we first propose an improved QMC lattice rule based on a change of variables and reformulate it as a tensor product rule in the transformed coordinates. We then develop an efficient implementation algorithm, called MDI-LR, by adapting the multilevel dimension iteration (MDI) idea first proposed by the authors in [22], for the improved QMC lattice rule. The proposed MDI-LR algorithm optimizes the function evaluations at integration points by clustering them and sharing computations via a symbolic-function based dimension/coordinate iteration procedure. This MDI-LR algorithm significantly reduces the computational complexity of the QMC lattice rule from an exponential growth in dimension d to a polynomial order $O\left(N^2{d}^3\right)$, where N denotes the number of integration points in each (transformed) coordinate direction. Thus, the MDI-LR effectively overcomes the CoD and revitalizes QMC lattice rules for high dimensional integration.

The remainder of this paper is organized as follows. In Section 2, we first briefly review the rank-one lattice rule and its properties. In Section 4, we introduce a reformulation of this lattice rule and proposed a tensor product generalization based on an affine transformation. In Section 3, we introduce our MDI-LR algorithm for efficiently implementing the proposed lattice rule based on a multilevel dimension iteration idea. In Section 5, we present extensive numerical experiments to test the performance of the proposed MDI-LR algorithm and compare its performance with the original lattice rule and the improved lattice rule with standard implementation. The numerical experiments show that the MDI-LR algorithm is much faster and more efficient in medium and high dimensional cases. In Section 6, we numerically examine the impact of parameters appeared in MDI-LR algorithm, including the choice of the generating vector $\mathbf{z}$ for the lattice rule. In Section 7, we present a detail numerical study of the computational complexity for the MDI-LR algorithm. This is achieved by using regression techniques to discover the relationship between CPU time and dimension d. Finally, the paper is concluded with a summary given in Section 8.

2. Preliminaries

In this section, we first briefly recall some basic materials about Quasi-Monte Carlo (QMC) lattice rules for evaluating integrals (1) and their properties. They will set stage for us to introduce our fast implementation algorithm in the later sections.

2.1. Quasi-Monte Carlo Lattice Rules

Lattice rules are a class of quasi-Monte Carlo (QMC) methods which were first introduced by Korobov in [12] to approximate (1) with periodic integrand f. A lattice rule is an equal-weight cubature rule whose cubature points are those points of an integration lattice that lie in the half-open unit cube ${[0, 1)}^d$. Every lattice point set includes the origin. The projection of the lattice points onto each coordinate axis are equally spaced. Essentially, the integral is approximated in each coordinate direction by a rectangle rule (or a trapezoidal rule if the integrand is periodic). The simplest lattice rules are called rank-one lattice rules. They use a lattice point set generated by multiples of a single generator vector, which are defined as follows.

Definition 1 

(rank-one lattice rule). An n-point rank-one lattice rule in d-dimensions, also known as the method of good lattice points, is a QMC method with cubature points

$${\mathbf{x}}_i=\left\{{\displaystyle \frac{i\mathbf{z}}{n}}\right\},i=0,1,\cdots ,n-1,$$

(4)

where $\mathbf{z}\in {\mathbb{Z}}^d$, known as the generating vector, is a d-dimensional integer vector having no factor in common with n, and the braces operator $\{·\}$ takes the fractional part of the input vector.

Every lattice rule can be written as a multiple sum involving one or more generating vectors. The minimal number of generating vectors required to generate a lattice rule is known as the rank of the rule. Besides rank-one lattice rules which have only one generating vector, there are also lattice rules having rank up to d. f is said to have an absolutely convergent Fourier series expansion if the following is true:

$$f\left(\mathbf{x}\right)=\sum _{\mathbf{h}\in Z^d}\widehat{f}\left(\mathbf{h}\right)e^{2\pi i\mathbf{h}·\mathbf{x}},i=\sqrt{-1},$$

(5)

where the Fourier coefficient is defined as follows:

$$\widehat{f}\left(\mathbf{h}\right)={\int }_{\Omega }f\left(\mathbf{x}\right)e^{-2\pi i\mathbf{h}·\mathbf{x}}d\mathbf{x}.$$

The following theorem gives two characterizations for the error of the lattice rules (cf. [13] (Theorem 1) and [10] (Theorem 5.2).

Theorem 1. 

Let $Q_{n,d}$ denote a lattice rule (not necessarily rank-one) and let $\mathcal{L}$ denote the associated integration lattice. If f has an absolutely convergent Fourier series (5), then the following is true:

$$Q_{n,d}\left(f\right)-I_d\left(f\right)=\sum _{\mathbf{h}\in {\mathcal{L}}^{\perp }\setminus \left\{\mathbf{0}\right\}}\widehat{f}\left(\mathbf{h}\right),$$

(6)

where ${\mathcal{L}}^{\perp }:=\{\mathbf{h}\in {\mathbb{Z}}^d:\mathbf{h}·\mathbf{x}\in \mathbb{Z}\forall \mathbf{x}\in \mathcal{L}\}$ is the dual lattice associated with $\mathcal{L}$.

Theorem 2. 

Let $Q_{n,d}$ denote a rank-one lattice rule with a generating vector $\mathbf{z}$. If f has an absolutely convergent Fourier series (5), then the following is true:

$$Q_{n,d}\left(f\right)-I_d\left(f\right)=\sum _{{\displaystyle \genfrac{}{}{0pt}{}{\mathbf{h}\in {\mathbb{Z}}^d\setminus \left\{\mathbf{0}\right\}}{\mathbf{h}·\mathbf{z}\equiv 0\left(modn\right)}}}\widehat{f}\left(\mathbf{h}\right).$$

(7)

It follows from (7) that the least upper bound of the error for the class $E_{\alpha }\left(c\right)$ of functions whose Fourier coefficients satisfy $|\widehat{f}\left(\mathbf{h}\right)|\le c{\left({\prod }_{i=1}^d{h}_i\right)}^{-\alpha }$ is given by the following:

$$\left|Q_{n,d}\left(f\right)-I_d\left(f\right)\right|\le c\sum _{{\displaystyle \genfrac{}{}{0pt}{}{\mathbf{h}\in {\mathbb{Z}}^d\setminus \left\{\mathbf{0}\right\}}{\mathbf{h}·\mathbf{z}\equiv 0\left(modn\right)}}}{\displaystyle \frac{1}{{\left({\prod }_{i=1}^d{\overline{h}}_i\right)}^{\alpha }}},$$

(8)

where $\alpha >1,c>0,\mathbf{h}=(h_1,h_2,\cdots ,h_d)$, ${\overline{h}}_i:=max(1,|h_i\left|\right)$, and $|h_i|$ denotes the absolute value of the i-th component of $\mathbf{h}$.

Let

$$P_{\alpha ,n,d}\left(\mathbf{z}\right):=\sum _{{\displaystyle \genfrac{}{}{0pt}{}{\mathbf{h}\in {\mathbb{Z}}^d\setminus \left\{\mathbf{0}\right\}}{\mathbf{h}·\mathbf{z}\equiv 0\left(modn\right)}}}{\displaystyle \frac{1}{{\left({\prod }_{i=1}^d{\overline{h}}_i\right)}^{\alpha }}}.$$

(9)

For fixed n and $\alpha$, a good lattice point $\mathbf{z}$ is so chosen to make $P_{\alpha ,n,d}\left(\mathbf{z}\right)$ as small as possible. It ws proved by Niederreiter in [23,24] (Theorem 2.11) that for a prime n (or a prime power) there exists a lattice point $\mathbf{z}$ such that the following is true:

$$P_{\alpha ,n,d}\left(\mathbf{z}\right)=O\left({\displaystyle \frac{{(logn)}^{\alpha d}}{n^{\alpha }}}\right).$$

(10)

This was achieved by proving that $P_{\alpha ,n,d}\left(\mathbf{z}\right)$ has the following expansion:

$$\begin{array}{cc}\hfill P_{\alpha ,n,d}\left(\mathbf{z}\right)& =-1+{\displaystyle \frac{1}{n}}\sum _{k=0}^{n-1}\prod _{j=1}^d\left(1+\sum _{h\in \setminus \left\{0\right\}}{\displaystyle \frac{e^{2\pi ikh{z}_j/n}}{{\left|h\right|}^{\alpha }}}\right)\hfill \\ \hfill & =-1+{\displaystyle \frac{1}{n}}\prod _{j=1}^d\left(1+2\zeta \left(\alpha \right)\right)+{\displaystyle \frac{1}{n}}\sum _{k=1}^{n-1}\prod _{j=1}^d\left(1+{\displaystyle \frac{{(-1)}^{\frac{\alpha }{2}+1}{\left(2\pi \right)}^{\alpha }}{\alpha !}}{B}_{\alpha }\left(\left\{{\displaystyle \frac{k{z}_j}{n}}\right\}\right)\right),\hfill \end{array}$$

(11)

where

$$\begin{array}{cc}\hfill \zeta \left(\alpha \right)& :=\sum _{j=1}^{\infty }{\displaystyle \frac{1}{j^{\alpha }}},\alpha >1;\hfill \end{array}$$

(12)

$$\begin{array}{cc}\hfill B_{\alpha }\left(\lambda \right)& :={\displaystyle \frac{{(-1)}^{\frac{\alpha }{2}+1}\alpha !}{{\left(2\pi \right)}^{\alpha }}}\sum _{h\in \mathbb{Z}\setminus \left\{0\right\}}{\displaystyle \frac{e^{2\pi ih\lambda }}{{\left|h\right|}^{\alpha }}},\lambda \in [0, 1];\hfill \end{array}$$

(13)

$$\begin{array}{cc}\hfill \left|\mathbf{h}\right|& :=\sqrt{h_1^2+\cdots +h_d^2}.\hfill \end{array}$$

(14)

As expected, the performance of a lattice rule depends heavily on the choice of the generating vector $\mathbf{z}$. For large n and d, an exhaustive search to find such a generating vector by minimizing some desired error criterion is practically impossible. Below we list a few common strategies for constructing lattice generating vectors.

2.2. Examples of Good Rank-One Lattice Rules

The first example is the Fibonacci lattice, we refer the reader to [10] for the details.

Example 1 

(Fibonacci lattice). Let $\mathbf{z}=(1,F_k)$ and $n=F_{k+1}$, where $F_k$ and $F_{k+1}$ are consecutive Fibonacci numbers. Then the resulting two-dimensional lattice set generated by $\mathbf{z}$ is called a Fibonacci lattice.

Fibonacci lattices in 2-d have a certain optimality property, but there is no obvious generalization to higher dimensions that retains the optimality property (cf. [10]).

The second example is so-called Korobov lattices, we refer the reader to [25,26] for the details.

Example 2 

(Korobov lattice). Let a be an integer satisfying $1\le a\le n-1$. Supposed a and n are relatively prime (i.e., their greatest common factor (GCF) is 1) and

$$\mathbf{z}=\mathbf{z}\left(a\right):=(1,a,a^2,\cdots ,a^{d-1})modn.$$

Then, the resulting d-dimensional lattice set generated by $\mathbf{z}$ is called a Korobov lattice.

It is easy to see that there are (at most) $n-1$ choices for the Korobov parameter a, which leads to (at most) $n-1$ choices for the generating vector $\mathbf{z}$. Thus it is feasible in practice to search through the (at most) $n-1$ choices and take the one that fulfills the desired error criterion such as the one that minimizes $P_{\alpha ,n,d}\left(\mathbf{z}\right)$, and (11) allows $P_{\alpha ,n,d}\left(\mathbf{z}\right)$ to be computed in $O\left(d{n}^2\right)$ operations (cf. [14]).

The last example is called the CBC lattice which is based on the component-by-component construction (cf. [27]).

Example 3 

(CBC lattice). Let ${\mathbb{N}}_n:=\{z\in \mathbb{Z}:1\le z\le n-1$ and suppose that a and n are relatively prime. Let $E_{n,d}^{\left(sh\right)}$ denote a shifted error operator defined in [27]. Then the generating vector $\mathbf{z}=(z_1,z_2,\cdots ,z_d)$ of the CBC lattice is defined component-wise as follows:

(i)

Set $z_1=1$.

(ii)

With $z_1$ held fixed, choose $z_2$ from ${\mathbb{N}}_n$ to minimize ${\left[E_{n,d}^{\left(sh\right)}\left((z_1,z_2)\right)\right]}^2$ in 2-d.

(iii)

With $z_1,z_2$ held fixed, choose $z_3$ from ${\mathbb{N}}_n$ to minimize ${\left[E_{n,d}^{\left(sh\right)}\left((z_1,z_2,z_3)\right)\right]}^2$ in 3-d.

(iv)

repeat the above process until all ${\left\{z_j\right\}}_{j=1}^d$ are determined.

It is well-known that [27], with general weights, the cost of the CBC algorithm is prohibitively expensive, thus in practice some special structure is always adopted, among them, product weights, order-dependent weights, finite-order weights, and POD (product and order-dependent) weights are commonly used. In each of the d steps of the CBC algorithm, the search space ${\mathbb{N}}_n$ has cardinality $n-1$. Then the overall search space for the CBC algorithm is reduced to a size of order $O\left(dn\right)$ (cf. [28] (page 11)). Hence, this provides a feasible way of constructing a generating vector $\mathbf{z}$.

Figure 1 shows a two-dimensional lattice with 81 points, the corresponding generating vectors are (1, 2), (1, 4) and (1, 7) respectively. Figure 2 shows a three-dimensional lattice with 81 points, and the corresponding generating vectors are, respectively, (1, 2, 4), (1, 4, 16), and (1, 7, 49).

3. Reformulation of Lattice Rules

Clearly, the lattice point set of each QMC lattice rule has some pattern or structure. Indeed, one main goal of this section is precisely to describe the pattern. We show that a lattice rule almost has a tensor product reformulation viewed in an appropriately transformed coordinate space via an affine transformation. This discovery allows us to introduce a tensor product rule as an improvement to the original QMC lattice rule. More importantly, the reformulation lays an important jump pad for us to develop an efficient and fast implementation algorithm (or solver), called the MDI-LR algorithm, based on the idea of multilevel dimension iteration [22], for evaluating the QMC lattice rule (2).

3.1. Construction of Affine Coordinate Transformations

From Figure 1 and Figure 2, we see that the distribution of lattice points are on lines/planes which are not parallel to the coordinate axes/planes. However, those lines/planes are parallel to each other, this observation suggests that they can be made to parallel to the coordinate axes/planes via affine transformations. Below, we prove that is indeed the case and explicitly construct such an affine transformation for a given QMC lattice rule.

Theorem 3. 

Let $\mathbf{z}=(z_1,z_2,\dots ,z_d)\in {\mathbb{Z}}^d$ be the generating vector of a rank-one lattice rule. The j-th lattice point associated with $\mathbf{z}$ is defined by ${\mathbf{x}}_j=\left\{\frac{j\mathbf{z}}{n}\right\}=\left(\left\{\frac{j{z}_1}{n}\right\},\dots ,\left\{\frac{j{z}_d}{n}\right\}\right)$, where the operator $\{·\}$ defines as taking the fractional part component-wise. The collection ${\left\{{\mathbf{x}}_j\right\}}_{j=0}^{n-1}$ thus forms the n-point set of a rank-one QMC lattice rule in dimension d. Define the following:

$$A=\left(\begin{array}{cccccc}{\displaystyle \frac{1}{z_1}}& -{\displaystyle \frac{1}{z_2}}& 0& \cdots & 0& 0\\ 0& {\displaystyle \frac{1}{z_2}}& -{\displaystyle \frac{1}{z_3}}& \cdots & 0& 0\\ ⋮& ⋮& ⋮& ⋮& ⋮& ⋮\\ 0& 0& 0& \cdots & {\displaystyle \frac{1}{z_{d-1}}}& -{\displaystyle \frac{1}{z_d}}\\ 0& 0& 0& \cdots & 0& 1\end{array}\right)and\mathbf{b}=\left(\begin{array}{c}0\\ 0\\ ⋮\\ -\left\{{\displaystyle \frac{n{x}_d}{z_d}}\right\}·{\displaystyle \frac{z_d}{n}}\end{array}\right).$$

(15)

Notice that $A\in {\mathbb{R}}^{d\times d}$ and $\mathbf{b}\in {\mathbb{R}}^d$. Then ${\mathbf{y}}_j:=abs(A{\mathbf{x}}_j+\mathbf{b}),j=0,1,\cdots ,n-1$ form a Cartesian grid in the new coordinate system, where $abs\left(\mathbf{y}\right)$ denotes the operation of taking the absolute value component-wise in the vector $\mathbf{y}$.

Proof. 

By the definition of ${\mathbf{x}}_j$, we have ${\mathbf{x}}_j={\left(\left\{{\displaystyle \frac{j{z}_1}{n}}\right\},\left\{{\displaystyle \frac{j{z}_2}{n}}\right\},\cdots ,\left\{{\displaystyle \frac{j{z}_d}{n}}\right\}\right)}^{⊺}$. A direct computation yields the following:

$$\begin{array}{cc}\hfill {\mathbf{y}}_j& =abs(A{\mathbf{x}}_j+\mathbf{b})=abs\left(\begin{array}{c}{\displaystyle \frac{1}{z_1}}\left\{{\displaystyle \frac{j{z}_1}{n}}\right\}-{\displaystyle \frac{1}{z_2}}\left\{{\displaystyle \frac{j{z}_2}{n}}\right\}\\ {\displaystyle \frac{1}{z_2}}\left\{{\displaystyle \frac{j{z}_2}{n}}\right\}-{\displaystyle \frac{1}{z_3}}\left\{{\displaystyle \frac{j{z}_3}{n}}\right\}\\ ⋮\\ {\displaystyle \frac{1}{z_{d-1}}}\left\{{\displaystyle \frac{j{z}_{d-1}}{n}}\right\}-{\displaystyle \frac{1}{z_d}}\left\{{\displaystyle \frac{j{z}_d}{n}}\right\}\\ \left\{{\displaystyle \frac{j{z}_d}{n}}\right\}-\left\{{\displaystyle \frac{n}{z_d}}\left\{{\displaystyle \frac{j{z}_d}{n}}\right\}\right\}·{\displaystyle \frac{z_d}{n}}\end{array}\right).\hfill \end{array}$$

(16)

Recall that $\left\{x\right\}$ and $\lfloor x\rfloor$ denote respectively the fractional and integer parts of the number x. Because

$${\displaystyle \frac{1}{z_i}}\left\{{\displaystyle \frac{j{z}_i}{n}}\right\}={\displaystyle \frac{1}{z_i}}\left({\displaystyle \frac{j{z}_i}{n}}-⌊{\displaystyle \frac{j{z}_i}{n}}⌋\right)={\displaystyle \frac{j}{n}}-{\displaystyle \frac{1}{z_i}}⌊{\displaystyle \frac{j{z}_i}{n}}⌋,$$

then

$${\displaystyle \frac{1}{z_{i-1}}}\left\{{\displaystyle \frac{j{z}_{i-1}}{n}}\right\}-{\displaystyle \frac{1}{z_i}}\left\{{\displaystyle \frac{j{z}_i}{n}}\right\}={\displaystyle \frac{1}{z_i}}⌊{\displaystyle \frac{j{z}_i}{n}}⌋-{\displaystyle \frac{1}{z_{i-1}}}⌊{\displaystyle \frac{j{z}_{i-1}}{n}}⌋,$$

and

$${\mathbf{y}}_j=abs\left(\begin{array}{c}{\displaystyle \frac{1}{z_1}}\left\{{\displaystyle \frac{j{z}_1}{n}}\right\}-{\displaystyle \frac{1}{z_2}}\left\{{\displaystyle \frac{j{z}_2}{n}}\right\}\\ {\displaystyle \frac{1}{z_2}}\left\{{\displaystyle \frac{j{z}_2}{n}}\right\}-{\displaystyle \frac{1}{z_3}}\left\{{\displaystyle \frac{j{z}_3}{n}}\right\}\\ ⋮\\ {\displaystyle \frac{1}{z_{d-1}}}\left\{{\displaystyle \frac{j{z}_{d-1}}{n}}\right\}-{\displaystyle \frac{1}{z_d}}\left\{{\displaystyle \frac{j{z}_d}{n}}\right\}\\ \left\{{\displaystyle \frac{j{z}_d}{n}}\right\}-\left\{{\displaystyle \frac{\left\{\frac{j{z}_d}{n}\right\}}{\frac{z_d}{n}}}\right\}·{\displaystyle \frac{z_d}{n}}\end{array}\right)=abs\left(\begin{array}{c}{\displaystyle \frac{1}{z_2}}\lfloor {\displaystyle \frac{j{z}_2}{n}}\rfloor -{\displaystyle \frac{1}{z_1}}\lfloor {\displaystyle \frac{j{z}_1}{n}}\rfloor \\ {\displaystyle \frac{1}{z_3}}\lfloor {\displaystyle \frac{j{z}_3}{n}}\rfloor -{\displaystyle \frac{1}{z_2}}\lfloor {\displaystyle \frac{j{z}_2}{n}}\rfloor \\ ⋮\\ {\displaystyle \frac{1}{z_d}}\lfloor {\displaystyle \frac{j{z}_d}{n}}\rfloor -{\displaystyle \frac{1}{z_{d-1}}}\lfloor {\displaystyle \frac{j{z}_{d-1}}{n}}\rfloor \\ {\displaystyle \frac{z_d}{n}}\lfloor j-{\displaystyle \frac{n}{z_d}}\lfloor {\displaystyle \frac{j{z}_d}{n}}\rfloor \rfloor \end{array}\right).$$

(17)

It is easy to check that the following is true:

$${\displaystyle \frac{1}{z_i}}⌊{\displaystyle \frac{j{z}_i}{n}}⌋-{\displaystyle \frac{1}{z_{i-1}}}⌊{\displaystyle \frac{j{z}_{i-1}}{n}}⌋=\left\{\begin{array}{cc}0,\hfill & 0\le j<{\displaystyle \frac{n}{z_i}}\\ {\displaystyle \frac{1}{z_i}},\hfill & {\displaystyle \frac{n}{z_i}}\le j<{\displaystyle \frac{n}{z_{i-1}}}\\ {\displaystyle \frac{1}{z_{i-1}}}-{\displaystyle \frac{1}{z_i}},\hfill & {\displaystyle \frac{n}{z_{i-1}}}\le j<{\displaystyle \frac{2n}{z_i}}\\ {\displaystyle \frac{2}{z_i}}-{\displaystyle \frac{1}{z_{i-1}}},\hfill & {\displaystyle \frac{2n}{z_i}}\le j<{\displaystyle \frac{2n}{z_{i-1}}}\\ {\displaystyle \frac{2}{z_{i-1}}}-{\displaystyle \frac{2}{z_i}},\hfill & {\displaystyle \frac{2n}{z_{i-1}}}\le j<{\displaystyle \frac{3n}{z_i}}\\ ⋮\hfill & ⋮\end{array}\right..$$

(18)

On the other hand, let the following be true:

$$\begin{array}{cc}\hfill & {\Gamma }_{n_1}^1:=\left\{y_{s_1}|y_{s_1}=abs\left({\displaystyle \frac{1}{z_2}}⌊{\displaystyle \frac{i{z}_2}{n}}⌋-{\displaystyle \frac{1}{z_1}}⌊{\displaystyle \frac{i{z}_1}{n}}⌋\right),i=0,1,\cdots ,n-1,s_1=0,1,\cdots ,n_1-1\right\},\hfill \\ \hfill & {\Gamma }_{n_2}^1:=\left\{y_{s_2}|y_{s_2}=abs\left({\displaystyle \frac{1}{z_3}}⌊{\displaystyle \frac{i{z}_3}{n}}⌋-{\displaystyle \frac{1}{z_2}}⌊{\displaystyle \frac{i{z}_2}{n}}⌋\right),i=0,1,\cdots ,n-1,s_2=0,1,\cdots ,n_2-1\right\},\hfill \\ \hfill & ⋮\hfill \\ \hfill & {\displaystyle \genfrac{}{}{0pt}{}{{\Gamma }_{n_{d-1}}^1:=\{y_{s_{d-1}}|y_{s_{d-1}}=abs\left(\frac{1}{z_d}⌊\frac{i{z}_d}{n}⌋-\frac{1}{z_{d-1}}⌊\frac{i{z}_{d-1}}{n}⌋\right),i=0,1,\cdots ,n-1,}{s_{d-1}=0,1,\cdots ,n_{d-1}-1\},}}\hfill \\ \hfill & {\Gamma }_{n_d}^1:=\left\{y_{s_d}|y_{s_d}=abs\left({\displaystyle \frac{z_d}{n}}⌊i-{\displaystyle \frac{n}{z_d}}⌊{\displaystyle \frac{i{z}_d}{n}}⌋⌋\right),i=0,1,\cdots ,n-1,s_d=0,1,\cdots ,n_d-1\right\},\hfill \\ \hfill & {\Gamma }_n^d:={\Gamma }_{n_1}^1\otimes {\Gamma }_{n_2}^1\otimes \cdots \otimes {\Gamma }_{n_d}^1,\hfill \end{array}$$

where

$$n_i={\displaystyle \frac{\mathrm{lcm}(z_i,z_{i+1})}{min(z_i,z_{i+1})}},i=1,2,\cdots ,d-1;n_d=⌈{\displaystyle \frac{n}{z_d}}⌉,$$

(19)

and $\mathrm{lcm}$ represents the least common multiple.

For any ${\mathbf{y}}_k={(y_{s_1},y_{s_2},\cdots ,y_{s_d})}^{⊺}\in {\Gamma }_n^d$, we have $k=s_1+s_2{n}_1+s_3{n}_1{n}_2+\cdots +s_d{n}_1{n}_2\cdots n_{d-1}$. Since $s_1=0,1,\cdots ,n_1,\cdots ,s_d=0,1,\cdots ,n_d$, then $k=0,1,\cdots ,n,\cdots ,$$(n_1{n}_2\cdots n_d)$. For ${\mathbf{y}}_j$ in the set described by (17), $\forall j=1,2,\cdots ,n$, we obtain the following:

$${\mathbf{y}}_j=abs\left(\begin{array}{c}{\displaystyle \frac{1}{z_2}}\lfloor {\displaystyle \frac{j{z}_2}{n}}\rfloor -{\displaystyle \frac{1}{z_1}}\lfloor {\displaystyle \frac{j{z}_1}{n}}\rfloor \\ {\displaystyle \frac{1}{z_3}}\lfloor {\displaystyle \frac{j{z}_3}{n}}\rfloor -{\displaystyle \frac{1}{z_2}}\lfloor {\displaystyle \frac{j{z}_2}{n}}\rfloor \\ ⋮\\ {\displaystyle \frac{1}{z_d}}\lfloor {\displaystyle \frac{j{z}_d}{n}}\rfloor -{\displaystyle \frac{1}{z_{d-1}}}\lfloor {\displaystyle \frac{j{z}_{d-1}}{n}}\rfloor \\ {\displaystyle \frac{z_d}{n}}\lfloor k-{\displaystyle \frac{n}{z_d}}\lfloor {\displaystyle \frac{j{z}_d}{n}}\rfloor \rfloor \end{array}\right).$$

(20)

Let $y_{i_1}:=abs({\displaystyle \frac{1}{z_2}}\lfloor {\displaystyle \frac{j{z}_2}{n}}\rfloor -{\displaystyle \frac{1}{z_1}}\lfloor {\displaystyle \frac{j{z}_1}{n}}\rfloor )$; t follows that there exists an $s_1$ such that $s_1=n_1-\lfloor {\displaystyle \frac{j}{n_1}}\rfloor ,$ resulting in $y_{i_1}=y_{s_1}\in {\Gamma }_{n_1}^1$. In the same way, $y_{i_2}\in {\Gamma }_{n_2}^1,\cdots ,y_{i_d}\in {\Gamma }_{n_d}^1$. Therefore, we conclude that ${\mathbf{y}}_j={(y_{i_1},y_{i_2},\cdots ,y_{i_d})}^{⊺}\in {\Gamma }_n^d$, that is, the transformed lattice points have the Cartesian product structure.    □

Lemma 1. 

Let ${\mathbf{x}}_j=\left\{{\displaystyle \frac{j\mathbf{z}}{n}}\right\}$ for $j=1,2,\cdots ,n-1$ denote the Korobov lattice point set, where $\mathbf{z}=(1,a,a^2,\cdots ,a^{d-1})$, $1\le a\le n-1$ and a is an integer parameter that determines the generating vector of the Korobov lattice. Assume that a and n are relatively prime. Define ${\mathbf{y}}_j:=\mathrm{abs}(A{\mathbf{x}}_j+\mathbf{b})$, $j=0,1,\cdots ,n-1$, which satisfies the conclusion of Theorem 3. Moreover, if $a=\lfloor n^{{\displaystyle \frac{1}{d}}}\rfloor$, then the number of points in each coordinate direction of the lattice set ${\Gamma }_n^d$ is the same, that is, $n_1=n_2=\cdots =n_d=a$, where $n_d$ denotes the number of lattice points along the d-th coordinate direction.

Proof. 

From Theorem 3 we have the following:

$${\mathbf{y}}_j=abs\left(\begin{array}{c}{\displaystyle \frac{1}{a}}\lfloor {\displaystyle \frac{ja}{n}}\rfloor \\ {\displaystyle \frac{1}{a^2}}\lfloor {\displaystyle \frac{j{a}^2}{n}}\rfloor -{\displaystyle \frac{1}{a}}\lfloor {\displaystyle \frac{ja}{n}}\rfloor \\ ⋮\\ {\displaystyle \frac{1}{a^{d-1}}}\lfloor {\displaystyle \frac{j{a}^{d-1}}{n}}\rfloor -{\displaystyle \frac{1}{a^{d-2}}}\lfloor {\displaystyle \frac{j{a}^{d-2}}{n}}\rfloor \\ {\displaystyle \frac{a^{d-1}}{n}}\lfloor j-{\displaystyle \frac{n}{a^{d-1}}}\lfloor {\displaystyle \frac{j{a}^{d-1}}{n}}\rfloor \rfloor \end{array}\right),$$

(21)

and

$$\begin{array}{cc}\hfill {\Gamma }_{n_1}^1& =\left\{y_{s_1}|y_{s_1}=abs\left({\displaystyle \frac{1}{a}}⌊{\displaystyle \frac{ja}{n}}⌋\right),j=0,1,\cdots ,n-1,s_1=0,1,\cdots ,n_1-1\right\}\hfill \\ \hfill & =\left\{0,{\displaystyle \frac{1}{a}},{\displaystyle \frac{2}{a}},\cdots ,{\displaystyle \frac{a-1}{a}}\right\},\hfill \\ \hfill {\Gamma }_{n_2}^1& =\left\{y_{s_2}|y_{s_2}=abs\left({\displaystyle \frac{1}{a^2}}⌊{\displaystyle \frac{j{a}^2}{n}}⌋-{\displaystyle \frac{1}{a}}⌊{\displaystyle \frac{ja}{n}}⌋\right),j=0,1,\cdots ,n-1,s_2=0,1,\cdots ,n_2-1\right\}\hfill \\ & =\left\{0,{\displaystyle \frac{1}{a^2}},{\displaystyle \frac{2}{a^2}},\cdots ,{\displaystyle \frac{a-1}{a^2}}\right\},\hfill \\ \hfill & ⋮\hfill \\ \hfill {\Gamma }_{n_{d-1}}^1& =\{y_{s_{d-1}}|y_{s_{d-1}}=abs\left({\displaystyle \frac{1}{a^{d-1}}}⌊{\displaystyle \frac{j{a}^{d-1}}{n}}⌋-{\displaystyle \frac{1}{a^{d-2}}}⌊{\displaystyle \frac{j{a}^{d-2}}{n}}⌋\right),j=0,1,\cdots ,n-1,\hfill \\ & s_{d-1}=0,1,\cdots ,n_{d-1}-1\}\hfill \\ \hfill & =\left\{0,{\displaystyle \frac{1}{a^{d-1}}},{\displaystyle \frac{2}{a^{d-1}}},\cdots ,{\displaystyle \frac{a-1}{a^{d-1}}}\right\},\hfill \\ \hfill {\Gamma }_{n_d}^1& =\{y_{s_d}|y_{s_d}=abs\left({\displaystyle \frac{a^{d-1}}{n}}⌊j-{\displaystyle \frac{n}{a^{d-1}}}⌊{\displaystyle \frac{j{a}^{d-1}}{n}}⌋⌋\right),j=0,1,\cdots ,n-1,\hfill \\ \hfill & s_d=0,1,\cdots ,n_d-1\}\hfill \\ \hfill & =\left\{0,{\displaystyle \frac{a^{d-1}}{n}},{\displaystyle \frac{2a^{d-1}}{n}},\cdots ,{\displaystyle \frac{n-a^{d-1}}{n}}\right\}.\hfill \end{array}$$

(22)

For ${\mathbf{y}}_j$ in the set described by (21), let $y_{i_1}:=abs\left({\displaystyle \frac{1}{a}}\lfloor {\displaystyle \frac{ja}{n}}\rfloor \right)$, it follows that there exists an $s_1$ such that $s_1=n_1-\lfloor {\displaystyle \frac{j}{n_1}}\rfloor$, resulting in $y_{i_1}={\displaystyle \frac{s_1}{a}}=y_{s_1}\in {\Gamma }_{n_1}^1$. Similarly, $y_{i_2}={\displaystyle \frac{s_2}{a^2}}=y_{s_2}\in {\Gamma }_{n_2}^1,\cdots ,y_{i_d}\in {\Gamma }_{n_d}^1$. Therefore, we conclude that ${\mathbf{y}}_j={(y_{i_1},y_{i_2},\cdots ,y_{i_d})}^{⊺}\in {\Gamma }_n^d$, Obviously, the transformed lattice points have the Cartesian product structure. Moreover, if $a={\left[n\right]}^{{\displaystyle \frac{1}{d}}}$, then

$$\begin{array}{cc}\hfill & n_i={\displaystyle \frac{\mathrm{lcm}(z_i,z_{i+1})}{min(z_i,z_{i+1})}}={\displaystyle \frac{z_{i+1}}{z_i}}=a,i=1,2,\cdots ,d-1,\hfill \\ \hfill & n_d=\lceil {\displaystyle \frac{n}{z_d}}\rceil ={\displaystyle \frac{a^d}{a^{d-1}}}=a.\hfill \end{array}$$

Hence $n_1=n_2=\cdots =n_{d-1}=n_d=a$. The proof is complete.    □

Left graph of Figure 3 shows a 2-d example of 81-point rank-one lattice with the generating vector $(1,4)$. Right graph displays transformed lattice under the affine coordinate transformation $\mathbf{y}=A\mathbf{x}+\mathbf{b}$ from ${\mathbb{R}}^2$ to itself, where

$$A=\left(\begin{array}{cc}1& -{\displaystyle \frac{1}{4}}\\ 0& 1\end{array}\right),\mathbf{b}=\left(\begin{array}{c}0\\ -\left\{{\displaystyle \frac{81x_2}{4}}\right\}·{\displaystyle \frac{4}{81}}\end{array}\right).$$

(23)

Figure 4 demonstrates a specific example in 3-d. The left graph is a 161-point rank-one lattice with generating vector $(1, 4, 16)$. The right one shows the transformed points under the affine coordinate transformation $\mathbf{y}=A\mathbf{x}+\mathbf{b}$ from ${\mathbb{R}}^3$ to itself, where the following is true:

$$A=\left(\begin{array}{ccc}1& -{\displaystyle \frac{1}{4}}& 0\\ 0& {\displaystyle \frac{1}{4}}& -{\displaystyle \frac{1}{16}}\\ 0& 0& 1\end{array}\right),\mathbf{b}=\left(\begin{array}{c}0\\ 0\\ -\left\{{\displaystyle \frac{161x_3}{16}}\right\}·{\displaystyle \frac{16}{161}}\end{array}\right).$$

(24)

3.2. Improved Lattice Rules

From Figure 3 and Figure 4 we see that the transformed lattice point sets do not exactly form tensor product grids because many lines miss one point. By adding those “missing" points which can be performed systematically, we easily make them become tensor product grids in the transformed coordinate system. Since more integration points are added to the QMC lattice rule, the resulting quadrature rule is expected to be more accurate (which is supported by our numerical tests), hence, it is an improvement to the original QMC lattice rule. We also note that those added points would correspond to ghost points in the original coordinates.

Definition 2 

(Improved QMC lattice rule). Let $\mathbf{z}\in {\mathbb{R}}^d$ and ${\mathbf{x}}_i=\left\{{\displaystyle \frac{i\mathbf{z}}{n}}\right\},i=0,1,\cdots ,n-1,$ be a rank-one lattice point set and ${\mathbf{y}}_i:=A{\mathbf{x}}_i+\mathbf{b},i=0,1,\cdots ,n-1$ for some $A\in {\mathbb{R}}^{d\times d}$ and $\mathbf{b}\in {\mathbb{R}}^d$ (which uniquely determine an affine transformation). Suppose there exists $n^{\ast }(<<n)$ points so that together the $n+n^{\ast }$ points form a tensor product grid in the transformed coordinate system, then the QMC lattice rule obtained by using those $n+n^{\ast }$ sampling points is called an improved QMC lattice rule, and denoted by ${\widehat{Q}}_{n,d}\left(f\right)$.

Figure 5 shows a 81-point (i.e., $n=81$) 2-d rank-one lattice with the generating vector $(1,7)$, the transformed lattice (middle), and the improved tensor product grid (right). Three points (in red color) are added on the top; so, $n^{\ast }=3$ for this example.

4. The MDI-LR Algorithm

Since an improved rank-one lattice is a tensor product grid in the transformed coordinate system and its corresponding quasi-Monte Carlo (QMC) rule is a tensor product rule with equal weight, $w={\displaystyle \frac{1}{n+n^{\ast }}}$. This tensor product improvement allows us to apply the multilevel dimension iteration (MDI) approach, which was proposed by the authors in [22], for a fast implementation of the original QMC lattice rule, especially in the high dimension case. The resulting algorithm will be called the MDI-LR algorithm throughout this paper,

Formulation of the MDI-LR Algorithm

To formulate our MDI-LR algorithm, we first recall the MDI idea/algorithm in simple terms (cf. [22]). For a tensor product rule, we need to compute a multi-summation with variable limits as follows:

$$\sum _{i_1=1}^{n_1}\sum _{i_2=1}^{n_2}\cdots \sum _{i_d=1}^{n_d}f({\xi }_{i_1},{\xi }_{i_2},\cdots ,{\xi }_{i_d}),$$

which involves $n_1{n}_2\cdots n_d$ function evaluations for the given function f if one uses the conventional approach by computing function value at each point independently, that inevitably leads to the curse of dimensionality (CoD). To make computation feasible in high dimensions, it is imperative to save the computational cost by evaluating the summation more efficiently.

The main idea of the MDI approach proposed in [22] is to compute those $n_1{n}_2\cdots n_d$ function values in cluster (not independently) and to compute the summation layer-by-layer based on a dimension iteration with help of symbolic computation. To that end, we write the following:

$$\sum _{i_1=1}^{n_1}\sum _{i_2=1}^{n_2}\cdots \sum _{i_d=1}^{n_d}f({\xi }_{i_1},{\xi }_{i_2},\cdots ,{\xi }_{i_d})=\sum _{i_{m+1}=1}^{n_{m+1}}\cdots \sum _{i_d=1}^{n_d}{f}_{d-m}({\xi }_{i_{m+1}},\cdots ,{\xi }_d),$$

(25)

where $1\le m<<d$ is fixed and

$$f_{d-m}(x_1,\cdots ,x_{d-m}):=\sum _{i_1=1}^{n_1}\cdots \sum _{i_m=1}^{n_m}f({\xi }_{i_1},\cdots ,{\xi }_{i_m},x_1,\cdots ,x_{d-m}),$$

The MDI approach recursively generates a sequence of symbolic functions $\{f_{d-m},f_{d-2m},$$\cdots ,f_{d-lm}\}$; each function has m fewer arguments than its predecessor (because the dimension is reduced by m at each iteration). As already mentioned above, the MDI approach explores the lattice structure of the tensor product integration point set; instead of evaluating function values at all integration points independently, it evaluates them in cluster and iteratively along m-coordinate directions, and the function evaluation at any integration point is not completed until the last step of the algorithm is executed. In some sense, the implementation strategy of the MDI approach is to trade large space complexity for low time complexity. That being said, however, the price to be paid by the MDI approach for the speedy evaluation of the multi-summation is that those symbolic function needs to be saved during the iteration process, which often takes up more computer memory.

For example, consider 2-d function $f(x_1,x_2)=x_1^2+x_1{x}_2+x_2^2$ and let $n_1=n_2=N$. In the standard approach, to compute the function value $f({\xi }_{i_1},{\xi }_{i_2})$ at an integration point $({\xi }_{i_1},{\xi }_{i_2})$, one needs to compute three multiplications ${\xi }_{i_1}\ast {\xi }_{i_1}={\xi }_{i_1}^2$, ${\xi }_{i_1}\ast {\xi }_{i_2}$ and ${\xi }_{i_2}\ast {\xi }_{i_2}={\xi }_{i_2}^2$, and two additions. To compute $N^2$ function values, it requires a total of $3N^2$ multiplications and $3N^2-1$ additions. On the other hand, the first for-loop of the MDI approach generates $f_1\left(x\right)={\sum }_{i_2}^{n}f(x,{\xi }_{i_2})$ which requires N evaluations of ${\xi }_{i_2}\ast x_1$ (symbolic computations) and N evaluations of ${\xi }_{i_2}\ast {\xi }_{i_2}$, as well as $3(N-1)$ additions. The second for-loop generates ${\sum }_{i_1=1}^N{f}_1\left({\xi }_{i_1}\right)$ which requires N evaluations of ${\xi }_{i_1}\ast {\xi }_{i_1}$ and N evaluations of ${\xi }_{i_1}\ast {\overline{\xi }}_{i_2}$, as well as $3N-1$ additions. After the second for-loop completes, we obtain the summation value. The computation complexity of the MDI approach consists of a total of $4N$ multiplications and $6N-4$ additions. Which is much cheaper than the standard approach. In fact, the speedup is even more dramatic in higher dimensions.

It is easy to see that the MDI approach can not be applied to the QMC rule (2) because it is not in a multi-summation form. However, we have showed in Section 3 that this obstacle can be overcome by a simple affine coordinate transformation (i.e., change of variables) and adding a few integration points.

Let $\mathbf{y}=A\mathbf{x}+\mathbf{b}$ denote the affine transformation, then the integral (1) is equivalent to the following:

$$I_d\left(f\right)={\displaystyle \frac{1}{\left|A\right|}}{\int }_{\widehat{\Omega }}f\left(A^{-1}(\mathbf{y}-\mathbf{b})\right)d\mathbf{y}={\displaystyle \frac{1}{\left|A\right|}}{\int }_{\widehat{\Omega }}g\left(\mathbf{y}\right)d\mathbf{y},$$

(26)

where $\left|A\right|$ stands for the determinant of $A\in {\mathbb{R}}^{d\times d}$ and

$$g\left(\mathbf{y}\right):=f\left(A^{-1}(\mathbf{y}-\mathbf{b})\right),\widehat{\Omega }:=\left\{\mathbf{y}|\mathbf{y}=A\mathbf{x}+\mathbf{b},\mathbf{x}\in \Omega \right\}.$$

Then, our improved QMC rank-one lattice rule for (2) in the $\mathbf{y}$-coordinate system takes the following form:

$${\widehat{Q}}_{n,d}\left(f\right)={\displaystyle \frac{1}{n+n^{\ast }}}\sum _{i=0}^{n+n^{\ast }-1}f\left({\mathbf{x}}_i\right)={\displaystyle \frac{1}{\left|A\right|}}\sum _{s_1=1}^{n_1}\sum _{s_2=1}^{n_2}\cdots \sum _{s_d=1}^{n_d}g(y_{s_1},y_{s_2},\cdots ,y_{s_d}).$$

(27)

Let the following be true:

$$J(g,\Omega ):=\sum _{s_1=1}^{n_1}\sum _{s_2=1}^{n_2}\cdots \sum _{s_d=1}^{n_d}g(y_{s_1},y_{s_2},\cdots ,y_{s_d}),$$

Clearly, it is a multi-summation with variable limits. Thus, we can apply the MDI approach to compute it efficiently. Before doing that, we first need to extend the MDI algorithm, Algorithm 2.3 of [22], to the case of variable limits. We name the extend algorithm as MDI$(d,g,{\Omega }_d,{\mathbf{N}}_d,m)$, which is defined in Algorithm 1 below.

Algorithm 1 MDI(d, g, $\Omega ,{\mathbf{N}}_d,m$)

Inputs:  $d(\ge 4),g,\Omega ,m(=1, 2, 3),{\mathbf{N}}_k=(n_1,n_2,\cdots ,n_k),k=1,2,\cdots ,d.$ Output: $J=J(g,\Omega )$. 1: ${\Omega }_d=\Omega$, $g_d=g$, $\ell =\left[{\displaystyle \frac{d}{m}}\right]$. 2: for $k=d:-m:d-\ell m$ (the index is decreased by m at each iteration) do 3:     ${\Omega }_{d-m}=P_k^{k-m}{\Omega }_k$. 4:     Construct symbolic function $g_{k-m}$ by (28) below). 5:     MDI$(k,g_k,{\Omega }_k,{\mathbf{N}}_k,m)$:=MDI$(k-m,g_{k-m},{\Omega }_{k-m},{\mathbf{N}}_{k-m},m)$. 6: end for 7: $J=$ MDI$(d-\ell m,g_{d-\ell m},{\Omega }_{d-\ell m},{\mathbf{N}}_{d-\ell m},m)$. 8: return J.

where $P_k^{k-m}$ denotes the natural embedding from ${\mathbb{R}}^k$ to ${\mathbb{R}}^{k-m}$ by deleting the first m components of vectors in ${\mathbb{R}}^k$, and the following is true:

$$g_{k-m}(s_1,\cdots ,s_{k-m})=\sum _{i_1,\cdots ,i_m=1}^{n_1,\cdots ,n_m}{w}_{i_1}{w}_{i_2}\cdots w_{i_m}{g}_k\left(({\xi }_1,\cdots ,{\xi }_m,s_1,\cdots ,s_{k-m})\right).$$

(28)

Remark 1. 

(a) 

Algorithm 1 recursively generates a sequence of symbolic functions $\{g_d,g_{d-m},$$g_{d-2m},$$\cdots g_{d-\ell m}\}$, each function has m fewer arguments than its predecessor.

(b) 

Since $m\le 3$, when $d=2,3$, we simply use the underlying low dimensional QMC quadrature rules. As was performed in [22], we name those low dimensional algorithms as 2d-MDI$(g,\Omega ,{\mathbf{N}}_2)$ and 3d-MDI$(g,\Omega ,{\mathbf{N}}_3)$, and introduce the following conventions.

−

If $k=1$, set MDI$(k,g_k,{\Omega }_k,n_1,m):=J(g_k,{\Omega }_k)$, which is computed by using the underlying 1-d QMC quadrature rule.

−

If $k=2$, set MDI$(k,g_k,{\Omega }_k,{\mathbf{N}}_k,m):=$ 2d-MDI$(g_k,{\Omega }_k,{\mathbf{N}}_k)$.

−

If $k=3$, set MDI$(k,g_k,{\Omega }_k,{\mathbf{N}}_k,m):=$ 3d-MDI$(g_k,{\Omega }_k,{\mathbf{N}}_k)$.

We note that when $k=1,2,3$, the parameter m becomes a dummy variable and can be given any value.

(c) 

We also note that the MDI algorithm in [22] has an additional parameter r which selects the 1-d quadrature rule. However, such a choice is not needed here because the underlying QMC rule is used as the 1-d quadrature rule.

We are now ready to define our MDI-LR algorithm, which is denoted by MDI-LR$(d,g,{\Omega }_d,{\mathbf{N}}_d,m)$, which is defined in Algorithm 2 below, by using the above MDI algorithm to evaluate ${\widehat{Q}}_{n,d}\left(f\right)$ in (27).

Algorithm 2 MDI-LR(f, $\Omega ,d,a,n$)

Inputs: $f,\Omega ,d,a,n$. Output: ${\widehat{Q}}_{n,d}\left(f\right)=Q_{n+n^{\ast },d}\left(f\right)$. 1: Initialize $\mathbf{z}=(1,a,a^2,\cdots ,a^{d-1})$, $J=0,Q=0$, $m=1$. 2: Construct matrix A and $\mathbf{b}$ by (15). 3: $g\left(\mathbf{y}\right):=f\left(A^{-1}(\mathbf{y}-\mathbf{b})\right)$. 4: Generate the vector ${\mathbf{N}}_d$ by (19). 5: $\widehat{\Omega }:=\left\{\mathbf{y}|\mathbf{y}=A\mathbf{x}+\mathbf{b},\mathbf{x}\in \Omega \right\}.$ 6: $J=$MDI$(d,g,\widehat{\Omega },{\mathbf{N}}_d,m)$ 7: $Q={\displaystyle \frac{J}{\left|A\right|}}$. 8: return ${\widehat{Q}}_{n,d}\left(f\right)=Q$.

Noting that, here, we set $m=1$, that is, the dimension is reduced by 1 at each dimension iteration; this is because the numerical tests of [22] show that, when $m=1$, the MDI algorithm is more efficient than when $m>1$. Also, the upper limit vector ${\mathbf{N}}_d$ depends on the choice of the underlying QMC rule. In Lemma 1 we showed that when $N=[n^{{\displaystyle \frac{1}{d}}}]$ and $a=N$, then $n_1=n_2=\cdots =n_d=N$, that is, the number of integration points is the same in each (transformed) coordinate direction.

5. Numerical Performance Tests

In this section, we present extensive and purposely designed numerical experiments to gauge the performance of the proposed MDI-LR algorithm and to demonstrate its superiority over the standard implementations of the QMC lattice rule (SLR) and the improved lattice rule (Imp-LR) for computing high dimensional integrals. All our numerical experiments are performed in Matlab on a desktop PC with Intel(R) Xeon(R) Gold 6226R CPU 2.90GHz and 32GB RAM. It should be noted that the MDI-LR algorithm does not require any prior knowledge of the integrand’s smoothness, which makes it applicable to a broad class of problems, including those with limited regularity.

5.1. Two and Three-Dimensional Tests

We first test our MDI-LR on simple 2- and 3-d examples and to compare its performance (in terms of the CPU time) with the SLR and Imp-LR methods.

Test 1. Let $\Omega ={[0, 1]}^2$ and consider the following 2-d integrands:

$$f\left(x\right):={\displaystyle \frac{x_{2}exp\left(x_1{x}_2\right)}{e-2}};\widehat{f}\left(x\right):=sin\left(2\pi +x_1^2+x_2^2\right).$$

(29)

Table 1. Relative errors and CPU times of SLR, Improved LR and MDI-LR simulations with $N=[n^{{\displaystyle \frac{1}{d}}}]$, $a=N$, $n_1=n_2=N$ for approximating $I_2\left(f\right)$.

	SLR (Standard LR)		Imp-LR (Improved LR)		MDI-LR
Total Nodes ($\mathit{n}$)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)
101	$1.332\times {10}^{-2}$	0.0422	$1.218\times {10}^{-3}$	0.0423	$1.218\times {10}^{-3}$	0.0877
501	$5.169\times {10}^{-3}$	0.0567	$2.520\times {10}^{-4}$	0.0547	$2.520\times {10}^{-4}$	0.3230
1001	$4.051\times {10}^{-3}$	0.0610	$1.269\times {10}^{-4}$	0.0657	$1.269\times {10}^{-4}$	0.5147
5001	$2.570\times {10}^{-3}$	0.0755	$2.489\times {10}^{-5}$	0.0754	$2.489\times {10}^{-5}$	1.6242
10,001	$2.094\times {10}^{-4}$	0.0922	$1.220\times {10}^{-5}$	0.0921	$1.220\times {10}^{-5}$	3.9471
40,001	$7.294\times {10}^{-5}$	0.1782	$3.050\times {10}^{-6}$	0.1787	$3.050\times {10}^{-6}$	7.0408

and

Table 2. Relative errors and CPU times of SLR, Improved LR and MDI-LR simulations with $N=[n^{{\displaystyle \frac{1}{d}}}]$, $a=N$, $n_1=n_2=N$ or approximating $I_2\left(\widehat{f}\right)$.

	SLR (Standard LR)		Imp-LR(Improved LR)		MDI-LR
Total Nodes ($\mathit{n}$)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)
101	$1.163\times {10}^{-2}$	0.0415	$1.072\times {10}^{-3}$	0.0410	$1.072\times {10}^{-3}$	0.0980
501	$6.794\times {10}^{-3}$	0.0539	$1.399\times {10}^{-4}$	0.0546	$1.399\times {10}^{-4}$	0.3498
1001	$3.814\times {10}^{-3}$	0.0647	$7.040\times {10}^{-5}$	0.0653	$7.040\times {10}^{-5}$	0.5028
5001	$1.858\times {10}^{-3}$	0.0723	$1.3411\times {10}^{-5}$	0.0733	$1.341\times {10}^{-5}$	1.7212
10,001	$1.175\times {10}^{-4}$	0.0965	$6.759\times {10}^{-6}$	0.0945	$6.759\times {10}^{-6}$	3.4528
40,001	$2.937\times {10}^{-5}$	0.1386	$1.689\times {10}^{-6}$	0.1399	$1.689\times {10}^{-6}$	6.1104

present the computational results (errors and CPU times) of the SLR, Imp-LR and MDI-LR method for approximating $I_2\left(f\right)$ and $I_2\left(\widehat{f}\right)$, respectively. Recall that the Imp-LR is obtained by adding some sampling points on the boundary of the integration domain in the transformed coordinates, and the MDI-LR algorithm provides a fast implementation of the Imp-LR using the MDI approach. From Table 1 and Table 2, we observe that in low dimensions (e.g., $d=2$), all three methods require very little CPU time, and the SLR method may even be slightly faster than the Imp-LR and MDI-LR methods. Since the Imp-LR and MDI-LR methods use additional sampling points on the boundary, which leads to slightly higher accuracy compared to SLR. Moreover, the MDI-LR method is specifically designed to accelerate the Imp-LR for computing high-dimensional integrals. As the dimension increases, the advantage of the MDI-LR becomes significant: it achieves much higher accuracy while maintaining moderate CPU time, resulting in substantially lower computational complexity and greater efficiency than SLR in high dimensions.

Test 2. Let $\Omega ={[0, 1]}^3$ and we consider the following 3-d integrands:

$$f\left(x\right):={\displaystyle \frac{exp\left(x_1+x_2+x_3\right)}{{(e-1)}^3}};\widehat{f}\left(x\right):=sin\left(2\pi +x_1^2+x_2^2+x_3^2\right).$$

(30)

Table 3. Relative errors and CPU times of SLR, Improved LR and MDI-LR simulations with $N=[n^{{\displaystyle \frac{1}{d}}}]$, $a=N$, $n_1=n_2=n_3=N$ for computing $I_3\left(f\right)$.

	SLR (Standard LR)		Imp-LR (Improved LR)		MDI-LR
Total Nodes ($\mathit{n}$)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)
101	$3.426\times {10}^{-3}$	0.0574	$4.985\times {10}^{-3}$	0.0588	$4.985\times {10}^{-3}$	0.0877
1001	$6.276\times {10}^{-3}$	0.0634	$1.249\times {10}^{-3}$	0.0654	$1.249\times {10}^{-3}$	0.2684
10001	$9.920\times {10}^{-4}$	0.0833	$3.124\times {10}^{-4}$	0.0877	$3.124\times {10}^{-4}$	0.6322
100,001	$5.717\times {10}^{-4}$	0.1500	$5.907\times {10}^{-5}$	0.1499	$5.907\times {10}^{-5}$	2.5866
1,000,001	$1.369\times {10}^{-5}$	1.0589	$1.249\times {10}^{-5}$	1.0587	$1.249\times {10}^{-5}$	14.737
10,000,001	$8.441\times {10}^{-6}$	9.8969	$3.124\times {10}^{-6}$	10.280	$3.124\times {10}^{-6}$	91.897

and

Table 4. Relative errors and CPU times of SLR, Improved LR and MDI-LR simulations with $N=[n^{{\displaystyle \frac{1}{d}}}]$, $a=N$, $n_1=n_2=n_3=N$ for computing $I_3\left(\widehat{f}\right)$.

	SLR (Standard LR)		Imp-LR (Improved LR)		MDI-LR
Total Nodes ($\mathit{n}$)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)
101	$1.866\times {10}^{-2}$	0.0580	$1.008\times {10}^{-3}$	0.0554	$1.008\times {10}^{-3}$	0.1366
1001	$9.746\times {10}^{-3}$	0.0628	$2.739\times {10}^{-4}$	0.0649	$2.739\times {10}^{-4}$	0.3804
10,001	$1.001\times {10}^{-3}$	0.0820	$6.337\times {10}^{-5}$	0.0828	$6.337\times {10}^{-5}$	1.1032
100,001	$7.063\times {10}^{-4}$	0.1443	$1.326\times {10}^{-5}$	0.1557	$1.326\times {10}^{-5}$	4.8794
1,000,001	$2.211\times {10}^{-5}$	1.1163	$2.810\times {10}^{-6}$	1.2104	$2.810\times {10}^{-6}$	20.305
10,000,001	$1.650\times {10}^{-5}$	10.207	$7.026\times {10}^{-7}$	10.427	$7.026\times {10}^{-7}$	101.22

present the simulation results (errors and CPU time) of the SLR, Imp-LR, and MDI-LR methods for computing $I_3\left(f\right)$ and $I_3\left(\widehat{f}\right)$ in Test 2. We observe that the SLR method requires less CPU time in both simulations. The advantage of the MDI-LR method in accelerating the computation does not materialize in low dimensions as seen in Test 1. Once again, the Imp-LR and MDI-LR have higher accuracy compared to the SLR method because they use additional sampling points on the boundary of the transformed domain.

5.2. High Dimensional Tests

Since the MDI-LR method is designed for computing high dimensional integrals, its performance for $d>>1$ is more important and anticipated, which is indeed the main task of this subsection. First, we test and compare the performance (in terms of CPU time) of the SLR, Imp-LR, and MDI-LR methods for computing high dimensional integrals as the number of lattice points grows due to the dimension increases. Then, we also test the performance of the SLR and MDI-LR methods for computing high dimensional integrals when the number of lattice points increases slowly in the dimension d.

Test 3. Let $\Omega ={[0, 1]}^d$ for $2\le d\le 50$ and consider the following Gaussian integrand:

$$f\left(x\right)={\displaystyle \frac{1}{\sqrt{2\pi }}}exp\left(-{\displaystyle \frac{1}{2}}{\left|x\right|}^2\right),$$

(31)

where $\left|x\right|$ stands for the Euclidean norm of the vector $x\in {\mathbb{R}}^d$.

Table 5. Relative errors and CPU times of SLR, Improved LR and MDI-LR simulations with $N=[n^{{\displaystyle \frac{1}{d}}}]$, $a=N$, $n_1=\cdots =n_d=N$ for computing $I_d\left(f\right)$.

	SLR (Standard LR) Total Nodes ($1+{10}^{\mathit{d}}$)		Imp-LR (Improved LR) Total Nodes ($1.1\times {10}^{\mathit{d}}$)		MDI-LR Total Nodes ($1.1\times {10}^{\mathit{d}}$)
Dimension ($\mathit{d}$)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)
2	$4.802\times {10}^{-3}$	0.0622	$5.398\times {10}^{-4}$	0.0637	$5.398\times {10}^{-4}$	0.1335
4	$3.796\times {10}^{-3}$	0.1068	$1.131\times {10}^{-3}$	0.1206	$1.131\times {10}^{-3}$	0.5780
6	$7.780\times {10}^{-3}$	1.2450	$1.723\times {10}^{-3}$	1.2745	$1.723\times {10}^{-3}$	1.2890
8	$1.189\times {10}^{-2}$	124.91	$2.315\times {10}^{-3}$	126.85	$2.315\times {10}^{-3}$	1.4083
10	$1.602\times {10}^{-2}$	13,084	$2.908\times {10}^{-3}$	13,255	$2.908\times {10}^{-3}$	3.1418
11	$1.809\times {10}^{-2}$	132,927	$3.204\times {10}^{-3}$	141,665	$3.204\times {10}^{-3}$	3.8265
12	failed	failed	failed	failed	$3.501\times {10}^{-3}$	4.5919

shows the relative errors and CPU times of SLR, Imp-LR, and MDI-LR methods for approximating the Gaussian integral $I_d\left(f\right)$. The simulation results indicate that SLR and Imp-LR methods are more efficient when $d<7$, but they struggle to compute integrals when $d>11$ as the number of lattice points increases exponentially in the dimension. However, this is not a problem for the MDI-LR method, which can compute this high dimensional integral easily. Moreover, the MDI-LR method improves the accuracy of the original QMC rule significantly by adding some integration points on the boundary of the transformed domain.

Table 6. Relative errors and CPU times of SLR and MDI-LR simulations with the same number of integration points for computing $I_d\left(f\right)$.

			SLR		MDI-LR
Dimension ($\mathit{d}$)	Total Nodes ($\mathit{n}$)	$\mathit{a}$ Value	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)
2	1 + ${10}^3$	31	$4.8020\times {10}^{-4}$	0.0369	$6.1474\times {10}^{-5}$	0.432905
6	1 + ${10}^6$	10	$7.7798\times {10}^{-3}$	1.2450	$1.7745\times {10}^{-3}$	0.790102
10	1 + ${10}^6$	4	$5.3673\times {10}^{-2}$	1.2453	$1.8683\times {10}^{-2}$	0.582487
14	1 + ${10}^8$	4	$7.9282\times {10}^{-2}$	144.759	$2.6253\times {10}^{-2}$	0.536131
18	1 + ${10}^9$	3	$1.5827\times {10}^{-1}$	1649.59	$6.1158\times {10}^{-2}$	0.774606
22	1 + ${10}^{10}$	3	$2.0007\times {10}^{-1}$	18,694.04	$7.5249\times {10}^{-2}$	0.702708
26	1 + ${10}^{11}$	3	$2.4341\times {10}^{-1}$	217,381.41	$8.9527\times {10}^{-2}$	0.866122
30	1 + ${10}^{11}$	3	$2.9009\times {10}^{-1}$	269,850.87	$1.0399\times {10}^{-1}$	1.045107

shows the relative errors and CPU times of the SLR and MDI-LR methods for computing $I_d\left(f\right)$ when the number of lattice points increase slowly in the dimension d. As the dimension increases, the CPU time required by the SLR method also increases sharply (see Figure 6). When approximating the Gaussian integral of about 30 dimensions with ${10}^{11}$ lattice points, the SLR method requires 74 h to obtain a result with relatively low accuracy. In contrast, the MDI-LR method only takes about one second to obtain a more accurate value, this demonstrates that the acceleration effect of the MDI-LR method is quite dramatic.

It is well known that it is difficult to obtain high accuracy approximations in high dimensions because the number of integration points required is enormous. A natural question is whether the MDI-LR method can handle very high (i.e., $d\approx 1000$) dimensional integration with reasonable accuracy. First, we note that the answer is machine dependent, as expected. Next, we present a test on the computer at our disposal to provide a positive answer to this question

Test 4. Let $\Omega ={[0, 1]}^d$ and consider the following integrands:

$$f\left(x\right)=exp\left(\sum _{i=1}^d{(-1)}^{i+1}{x}_i\right),\widehat{f}\left(x\right)=\prod _{i=0}^d{\displaystyle \frac{1}{0.9^2+{(x_i-0.6)}^2}}.$$

(32)

We use the algorithm MDI-LR to compute $I_d\left(f\right)$ and $I_d\left(\widehat{f}\right)$ with parameters $a=8, 20$, and an increasing sequence of d. The computed results are presented in

Table 7. Computed results for $I_d\left(f\right)$ and $I_d\left(\widehat{f}\right)$ by algorithm MDI-LR.

	${\mathit{I}}_{\mathit{d}}\left(\mathit{f}\right)$ Nodes ($1\times 8^{\mathit{d}}$)			${\mathit{I}}_{\mathit{d}}\left(\widehat{\mathit{f}}\right)$ Nodes ($1\times {20}^{\mathit{d}}$)
Dimension ($\mathit{d}$)	$\mathit{a}$ Value	Relative Error	CPU Time (s)	$\mathit{a}$ Value	Relative Error	CPU Time (s)
10	8	$6.4884\times {10}^{-3}$	0.4329063	20	$1.6107\times {10}^{-3}$	0.9851172
100	8	$6.3022\times {10}^{-2}$	71.253076	20	$1.6225\times {10}^{-2}$	11.1203255
300	8	$1.7740\times {10}^{-1}$	1856.91018	20	$4.9469\times {10}^{-2}$	37.0903112
500	8	$2.7781\times {10}^{-1}$	8076.92429	20	$8.3801\times {10}^{-2}$	65.9497657
700	8	$3.6597\times {10}^{-1}$	20,969.96162	20	$1.1925\times {10}^{-1}$	108.989057
900	8	$4.4337\times {10}^{-1}$	47,870.50843	20	$1.5587\times {10}^{-1}$	157.487672
1000	8	$4.7845\times {10}^{-1}$	69,991.88017	20	$1.7462\times {10}^{-1}$	189.132615

. The simulation is stopped at $d=1000$ because it is already in the very high dimension regime. These tests demonstrate the efficacy and potential of the MDI-LR method in efficiently computing high dimensional integrals. However, we note that, in terms of efficiency and accuracy, the MDI-LR method underperforms its two companion methods; namely, the MDI-TP [22] and MDI-SG [29] methods, as shown in Figure 7. The main reason for the underperformance is that the original lattice rule is unable to provide high accuracy integral approximations and the MDI-LR is a fast implementation algorithm (i.e., solver) for the modified lattice rule, Imp-LR. Nevertheless, the lattice rule has its own advantages, such as allowing flexible integration points and giving better results for periodic integrands.

6. Influence of Parameters

The original MDI algorithm involves three crucial input parameters: r, m, and N. The parameter r determines the one-dimensional basis value quadrature rule, while m sets the step size in the multidimensional iteration, and N represents the number of integration points in each coordinate direction. The algorithm MDI-LR is similar to the original MDI, but uses the QMC rank-one lattice rule with generating vector $\mathbf{z}$, so the parameter r is muted. Here we focus on the Korobov approach in constructing the generating vector $\mathbf{z}$, which is defined as $\mathbf{z}=\mathbf{z}\left(a\right):=(1,a,a^2,\cdots ,a^{d-1})$. Moreover, the improved tensor product rule (in the transformed coordinate system) that is implemented by the algorithm Imp-LR has variable upper limits in the summation (cf. (27)); hence, N is now replaced by ${\mathbf{N}}_d$ which is determined by the underlying QMC lattice rule. Furthermore, as explained earlier, we set $m=1$ due to our experience in [22]. As a result, the only parameter to select is a. Below, we first test the influence of the Korobov parameter a on the efficiency of the algorithm MDI-LR and then test dependence of its performance on ${\mathbf{N}}_d$ and d.

6.1. Influence of Parameter a

In this subsection, we investigate the impact of the generating vector $\mathbf{z}=\mathbf{z}\left(a\right):=(1,a,a^2,\cdots ,a^{d-1})$ in the algorithm MDI-LR. We note that similar methods can be constructed using other $\mathbf{z}$.

Test 5. Let $\Omega ={[0, 1]}^d$ and consider the following integrands:

$$\begin{array}{ccc}f\left(x\right)={\displaystyle \frac{1}{\sqrt{2\pi }}}exp\left(-{\displaystyle \frac{1}{2}}{\left|x\right|}^2\right),\hfill & & \widehat{f}\left(x\right)=cos\left(2\pi +2\sum _{i=1}^d{x}_i\right),\hfill \\ & \tilde{f}\left(x\right)=\prod _{i=0}^d{\displaystyle \frac{1}{0.9^2+{(x_i-0.6)}^2}}.\hfill \end{array}$$

We compare the performance of the algorithm MDI-LR with different Korobov parameters a while holding other parameters unchanged when computing $I_d\left(f\right)$, $I_d\left(\widehat{f}\right)$, and $I_d\left(\tilde{f}\right)$.

Figure 8 shows the computed results for $d=5,10$ and $a=4, 6, 8, 10, 12, 14, 16$, respectively. We observe that the algorithm MDI-LR with different parameters a has different accuracy and the effect could be significant. These results indicate that the algorithm is most efficient when $a=N$, where $N=[n^{{\displaystyle \frac{1}{d}}}]$ and n represents the total number of integral points. This is because when a smaller a is used, although fewer integration points need to be evaluated in each coordinate direction in the first $d-1$ dimension iterations, since the total number of integral points n is the same, the amount of computation will increase dramatically. When using a larger a, more integration points need to be used in each coordinate direction in the first $d-1$ dimension iterations. Only when the integration points are equally distributed to each coordinate direction, the efficiency of the algorithm MDI-LR can be optimized. A total of 100 points are shown in Figure 9. When $a=2$, only 2 iterations in the $x_1$-direction are needed, but 50 iterations in the $x_2$-direction must performed, hence, a total of 52 iterations in the two directions are required. On the other hand, when $a=20$, a total of 25 iterations in the two directions are required. It is easy to check that the least total of 20 iterations occurs when $a=10$. The difference in accuracy is obvious, because the different a leads to different generating vector $\mathbf{z}$. Which in turn results in different integration points. We note that it was already well studied in the literature on how to choose a to achieve the highest accuracy (cf. [10]).

6.2. Influence of Parameter $N=[n^{{\displaystyle \frac{1}{d}}}]$

In the previous section, we know that the algorithm is most efficient when $a=N$, where N represents the number of integration points in each direction. This section aims to investigate the impact of N on the MDI-LR algorithm. For this purpose, we conduct tests by setting $a=N$ and $d=5$ and $d=10$.

Test 6. Let $\Omega$, f, $\widehat{f}$ and $\tilde{f}$ be the same as in Test 5.

Table 8. Performance comparison of algorithm MDI-LR with $d=5,10,a=N$ and $N=4$, $6,8,10,12,14,16$ for computing $I_d\left(f\right)$.

		$\mathit{d}=5$		$\mathit{d}=10$
N (n)	Korobov Parameter ($\mathit{a}$)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)
4 ($1+4^d$)	4	$8.6248\times {10}^{-3}$	0.1456465	$1.8003\times {10}^{-2}$	0.3336161
6 ($1+6^d$)	6	$3.8967\times {10}^{-3}$	0.1911801	$8.0284\times {10}^{-3}$	0.5690320
8 ($1+8^d$)	8	$2.2145\times {10}^{-3}$	0.3373442	$4.5314\times {10}^{-3}$	0.9552591
10 ($1+{10}^d$)	10	$1.4271\times {10}^{-3}$	0.3884146	$2.9078\times {10}^{-3}$	1.9385378
12 ($1+{12}^d$)	12	$9.9601\times {10}^{-4}$	0.6545521	$2.0234\times {10}^{-3}$	3.5639475
14 ($1+{14}^d$)	14	$7.3448\times {10}^{-4}$	0.7224777	$1.4889\times {10}^{-3}$	6.0036393
16 ($1+{16}^d$)	16	$5.6396\times {10}^{-4}$	1.0909097	$1.1414\times {10}^{-3}$	8.4313528

,

Table 9. Performance comparison of algorithm MDI-LR with $d=5,10,a=N$ and $N=4$, $6,8,10,12,14,16$ for computing $I_d\left(\widehat{f}\right)$.

		$\mathit{d}=5$		$\mathit{d}=10$
N (n)	Korobov Parameter ($\mathit{a}$)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)
4 ($1+4^d$)	4	$4.9621\times {10}^{-2}$	0.1323887	$1.0585\times {10}^{-1}$	0.2775234
6 ($1+6^d$)	6	$2.2181\times {10}^{-2}$	0.1955847	$4.6141\times {10}^{-2}$	0.4267706
8 ($1+8^d$)	8	$1.2558\times {10}^{-2}$	0.2689113	$2.5836\times {10}^{-2}$	0.5697773
10 ($1+{10}^d$)	10	$8.0791\times {10}^{-3}$	0.3227299	$1.6517\times {10}^{-2}$	0.7828456
12 ($1+{12}^d$)	12	$5.6328\times {10}^{-3}$	0.4056192	$1.1470\times {10}^{-2}$	0.9228344
14 ($1+{14}^d$)	14	$4.1513\times {10}^{-3}$	0.4940739	$8.4305\times {10}^{-3}$	1.0968489
16 ($1+{16}^d$)	16	$3.1863\times {10}^{-3}$	0.6079693	$6.4576\times {10}^{-3}$	1.2933549

and

Table 10. Performance comparison of algorithm MDI-LR with $d=5,10,a=N$ and $N=4$, $6,8,10,12,14,16$ for computing $I_d\left(\tilde{f}\right)$.

		$\mathit{d}=5$		$\mathit{d}=10$
N (n)	Korobov Parameter ($\mathit{a}$)	Relative Error	CPU Time (s)	Relative Error	CPU Time (s)
4 ($1+4^d$)	4	$1.9003\times {10}^{-2}$	0.1254485	$3.9895\times {10}^{-2}$	0.2460844
6 ($1+6^d$)	6	$8.5331\times {10}^{-3}$	0.1802281	$1.7625\times {10}^{-2}$	0.3613987
8 ($1+8^d$)	8	$4.8390\times {10}^{-3}$	0.2114595	$9.9155\times {10}^{-3}$	0.4414383
10 ($1+{10}^d$)	10	$3.1153\times {10}^{-3}$	0.2748469	$6.3531\times {10}^{-3}$	0.4892808
12 ($1+{12}^d$)	12	$2.1729\times {10}^{-3}$	0.3092816	$4.4172\times {10}^{-3}$	0.5859328
14 ($1+{14}^d$)	14	$1.6018\times {10}^{-3}$	0.3602077	$3.2488\times {10}^{-3}$	0.6783681
16 ($1+{16}^d$)	16	$1.2296\times {10}^{-3}$	0.4157161	$2.4897\times {10}^{-3}$	0.7819849

present a performance comparison for algorithm MDI-LR with $d=5,10$ and $N=4, 6, 8 , 10 , 12, 14, 16$, respectively. We note that the quality of the computed results also depend on types of the integrands. As expected, more integration points must be used to achieve a good accuracy for very oscillatory and fast growth integrands.

7. Computational Complexity

7.1. The Relationship Between the CPU Time and N

In this subsection, we examine the relationship between CPU time and the parameters $N=[n^{{\displaystyle \frac{1}{d}}}]$ and $a=N$ using a regression technique based on test data.

Figure 10 and Figure 11 show CPU time as a function of N obtained by the least squares regression with the fitted function given in

Table 11. Relationship between the CPU time and parameter N.

Integrand	a	m	d	Fitting Function	R-Square
$f\left(x\right)$	N	1	5	$h_1\left(N\right)=0.007569\times N^{1.772}$	0.9687
$\widehat{f}\left(x\right)$	N	1	5	$h_2\left(N\right)=0.02326\times N^{1.165}$	0.9920
$\tilde{f}\left(x\right)$	N	1	5	$h_3\left(N\right)=0.03592\times N^{0.8767}$	0.9946
$f\left(x\right)$	N	1	10	$h_4\left(N\right)=0.002136\times N^{2.992}$	0.9968
$\widehat{f}\left(x\right)$	N	1	10	$h_5\left(N\right)=0.05679\times N^{1.125}$	0.9984
$\tilde{f}\left(x\right)$	N	1	10	$h_6\left(N\right)=0.07872\times N^{0.8184}$	0.9901

. All results show that CPU time grows in proportion to $N^3$.

7.2. The Relationship Between the CPU Time and the Dimension d

In this subsection, we exploit the computational complexity (in terms of CPU time as a function of d) using the least squares regression on numerical test data.

Test 7. Let $\Omega ={[0,1]}^d$, we consider the following five integrands:

$$\begin{array}{cccc}& f_1\left(x\right)=exp\left(\sum _{i=1}^d{(-1)}^{i+1}{x}_i\right),\hfill & & f_2\left(x\right)=\prod _{i=1}^d{\displaystyle \frac{1}{0.9^2+{(x_i-0.6)}^2}},\hfill \\ & f_3\left(x\right)={\displaystyle \frac{1}{\sqrt{2\pi }}}exp\left(-{\displaystyle \frac{1}{2}}{\left|x\right|}^2\right),\hfill & & f_4\left(x\right)=cos\left(2\pi +\sum _{i=1}^{d}2x_i\right),\hfill \\ & f_5\left(x\right)=exp\left(\sum _{i=1}^d{(-1)}^{i+1}{x}_i^2\right),\hfill & & f_6\left(x\right)={(1+\sum _{i=1}^d{x}_i)}^{-(d+1)}.\hfill \end{array}$$

Figure 12 displays the the CPU time as functions of d obtained by the least square regression whose analytical expressions are given in

Table 12. The relationship between CPU time as a function of the dimension d.

Integrand	a	N	m	Fitting Function	R-Square
$f_1$	8	8	1	$g_1=1.057\times {10}^{-6}\times N^2{d}^3$	0.9973
	10	10	1	$g_2=1.192\times {10}^{-6}\times N^2{d}^3$	0.9995
	20	20	1	$g_3=1.433\times {10}^{-6}\times N^2{d}^3$	0.9978
$f_2$	10	10	1	$g_4=0.0001774\times N{d}^{1.611}$	0.9983
	14	14	1	$g_5=0.003028\times N{d}^{1.147}$	0.9987
	20	20	1	$g_6=0.000539\times N{d}^{1.41}$	0.9964
$f_3$	8	8	1	$g_7=7.334\times {10}^{-6}\times N^2{d}^3$	0.9983
	10	10	1	$g_8=9.321\times {10}^{-6}\times N^2{d}^3$	0.9986
	14	14	1	$g_9=1.339\times {10}^{-5}\times N^2{d}^3$	0.9972
$f_4$	10	10	1	$g_{10}=1.164\times {10}^{-6}\times N^2{d}^3$	0.9988
	20	20	1	$g_{11}=1.319\times {10}^{-6}\times N^2{d}^3$	0.9974
$f_5$	10	10	1	$g_{12}=6.479\times {10}^{-5}\times N^2{d}^{2.557}$	0.9996
	14	14	1	$g_{13}=1.164\times {10}^{-5}\times N^2{d}^3$	0.9993
$f_6$	10	10	1	$g_{14}=1.556\times {10}^{-6}\times N^2{d}^3$	0.9983
	20	20	1	$g_{15}=8.328\times {10}^{-6}\times N^2{d}^{2.431}$	0.9998

. We note that the parameters of the algorithm MDI-LR only affect the coefficients of the fitted function, not the power of the polynomials. These results show that the CPU time required by the proposed algorithm MDI-LR grows at most with polynomial order $O\left(d^3{N}^2\right)$.

We assess the quality of the fitted curves using the R-square criterion in Matlab, defined by R-$\mathrm{square}=1-{\displaystyle \frac{{\sum }_i^n{(y_i-{\widehat{y}}_i)}^2}{{\sum }_i^n{(y_i-\overline{y})}^2}}$, where $y_i$ is a test data output, ${\widehat{y}}_i$ is the predicted value, and $\overline{y}$ is the mean of $y_i$. As shown in Table 12, the R-square values of all fitted functions are close to 1, indicating their high accuracy. These results support the observation that the CPU time grows no more than cubically with the dimension d. Combined with the results of Test 6 in Section 6.2, we conclude that the computational cost of the proposed MDI-LR algorithm scales at most polynomially in the order of $O\left(N^2{d}^3\right)$.

8. Conclusions

In this paper, we develop a fast numerical algorithm, termed MDI-LR, for the efficient implementation of quasi-Monte Carlo (QMC) lattice rules in computing the d-dimensional integral of a given function. To formulate the algorithm, we first employ an affine transformation to map standard rank-one lattice points into a tensor-product-like lattice and then enhance computational reuse and scalability through a multilevel dimension iteration (MDI) approach. This design eliminates the need for explicitly storing integration points or independently evaluating function values, thereby improving both efficiency and scalability.

The main innovations of the proposed method are fourfold. First, the affine-transformed lattice enhances the uniformity of integration point distribution, particularly near domain boundaries. Second, the transformation allows us systematically to add a small number of supplementary points near the boundary of the integration domain to obtain a perfect tensor-product lattice in the new coordinate system. The tensor-product lattice gives a better coverage of the integration domain and results in a slightly higher accurate quadrature rule than the original QMC lattice rule with almost same number of integration points. Third, the transformed QMC lattice (i.e., the tensor-product lattice) can be seamlessly embedded into the Multidimensional Integration (MDI) acceleration framework, which substantially improves computational efficiency while maintaining the numerical accuracy of the quadrature rule. Finally, the proposed MDI-LR algorithm demonstrates excellent scalability and robustness in very high-dimensional problems (up to thousands of dimensions), surpassing direct implementation of QMC methods in both efficiency and accuracy.

Extensive numerical experiments confirm that the MDI-LR algorithm achieves a computational complexity of approximately $O\left(d^3{N}^2\right)$ or better, effectively mitigating the curse of dimensionality. These results indicate that the MDI-LR algorithm makes QMC lattice rules not only competitive but also practically applicable to large-scale high-dimensional integration problems. Future work will focus on extending the proposed framework to general Monte Carlo methods and applying it to high-dimensional partial differential equations and real-world computational models.