Multilevel Quasi-Interpolation on Chebyshev Sparse Grids

Abstract

This paper investigates the potential of utilising multilevel quasi-interpolation techniques on Chebyshev sparse grids for complex numerical computations. The paper starts by laying down the motivations for choosing Chebyshev sparse grids and quasi-interpolation methods with Gaussian kernels. It delves into the practical aspects of implementing these techniques. Various numerical experiments are performed to evaluate the efficiency and limitations of the multilevel quasi-sparse interpolation methods with dimensions two dimension and three dimension. The work ultimately aims to provide a comprehensive understanding of the computational efficiency and accuracy achievable through this approach, comparing its performance with traditional methods.

1. Introduction

Traditional interpolation methods, such as grid-based or radial basis function interpolation, encounter computational difficulties when dealing with multidimensional datasets. The computational complexity of these methods grows exponentially with the number of dimensions, rendering them similarly unfeasible on reasonable timeframes. Consequently, novel approaches are necessary to address the challenge of interpolation in multidimensional spaces.

The need for innovative solutions has driven the development of novel numerical methods that are capable of efficiently handling 2D, 3D, or high-dimensional data using higher-performance computers [1,2]. As a result, researchers have been able to make significant advancements in the various scientific domains mentioned, enabling the development of innovative solutions to complex problems [3].

2. Chebyshev Sparse Grids Technique

In the literature, a sparse grid technique has been proposed to overcome the curse of dimensionality with equally spaced grids for higher dimensional domains [4]. Georgoulis et al. [4] proposed an algorithm that reduces the requirement of a large number of data points on an equally spaced grid but keeps the simplicity of a grid structure in evaluating the interpolant. The construction of a sparse grid is defined as follows.

Define multi-index $\ell =(l_1,\dots ,l_d)\in {\mathbb{N}}^d$ and $(i_1,\dots ,i_d)\in {\mathbb{N}}^d$ as spatial positions. Define the point for that position as follows:

$$x_{\ell ,i}=(x_{l_1,i_1},\dots ,x_{l_d,i_d})\mathrm{with}{x}_{l_j,i_j}=2(i_j.2^{-l_j}-0.5)forj=1,\dots ,d.$$

We can now define the family of uniform grids ${\mathbb{G}}_{\ell }$ as the following set of points:

$${\mathbb{G}}_{\ell }=\{x_{\ell ,i}:i=(i_1,\dots ,i_d),i_j=0,1,\dots ,2^{l_j},j=1,\dots ,d\}.$$

The number of points $N_{\ell }$ in ${\mathbb{G}}_{\ell }$ is given as follows:

$$N_{\ell }=\prod _{j=1}^d(2^{l_j}+1).$$

If we have $\ell =(n,\dots ,n)$, ${\mathbb{G}}_{\ell }$ is the uniform full grid of equally spaced points of level n with distances between the points given by $h=2^{-n}$. The size of the grid $\mathbb{G}\ell$ is $N={(2^n+1)}^d$. We denote this full grid as ${\mathbb{G}}_{n,d}$. Now, we consider a sparse subset of uniform full grids, ${\mathbb{G}}_{n,d}$, as follows:

$${\tilde{\mathbb{G}}}_{n.d}=\bigcup _{|\ell |=n+(d-1)}{\mathbb{G}}_{\ell },$$

(1)

with $|\ell |=l_1+l_2+\cdots +l_d$. We refer to ${\tilde{\mathbb{G}}}_{n.d}$ as the sparse grid of level in dimension d. Figure 1 shows a visual representation of the sparse grid for $n=4$ and $d=2$. Notice that some of the grid points are included in more than one sub-grid; hence, there are some redundancies.

In an alternative formulation of the sparse grid, there are arguments that instead of using an equally spaced grid, one can use Chebyshev points to create grids on $[-1,1]$. For the multi-index $\ell =(l_1,\dots ,l_d)\in {\mathbb{N}}^d$ and $(i_1,\dots ,i_d)\in {\mathbb{N}}^d$, we can define

$$x_{l_j,i_j}^c=-cos\left({\displaystyle \frac{2i_j-1}{2\times 2^{l_j}}}\right)forj=1,\dots ,d$$

to have the point $x_{\ell ,i}^c=(x_{l_1,i_1}^c,\dots ,x_{l_d,i_d}^c)$. Similarly, we can define the family of Chebyshev grids as follows:

$${\mathbb{G}}_{\ell }^c=\{x_{\ell ,i}^c:i=(i_1,\dots ,i_d),i_j=0,1,\dots ,2^{l_j},j=1,\dots ,d\},$$

and the sparse subset of Chebyshev grids as follows:

$${\tilde{\mathbb{G}}}_{n.d}^c=\bigcup _{|\ell |=n+(d-1)}{\mathbb{G}}_{\ell }^c,$$

(2)

where ${\tilde{\mathbb{G}}}_{n.d}^c$ is referred to as the sparse Chebyshev grid of level n in dimension d. Figure 2 shows a visual representation of the sparse Chebyshev grid for $n=4$ and $d-2$. We observe that the sparse grid points are not equally spaced.

3. Quasi-Sparse Interpolation with Gaussian Kernels

In the previous formulation of the interpolation using RBF, we observed that it is required to solve a system of N linear equations, where N is the total number of points. Using a sparse grid of points as defined in the previous sub-section will reduce the total number of points and, subsequently, the total number of equations for the higher dimension compared to a full grid of points. However, that does not fully eliminate the ill-conditioning of the problems. Another method proposed in the literature to avoid solving the system of linear equations is to use quasi-interpolation. There is extensive discussion on error estimates in quasi-interpolation in the literature [5,6,7].

We use the idea of quasi-interpolation on the sparse grid with anisotropic Gaussian basis functions. If $c_{i,j}=|x_{i+1,j}-x_{i,j}|$, the distance between points $x_i$ and $x_{i+1}$ in dimension j for $j=1,\dots ,d$. Then, the diagonal matrix can be defined as follows:

$$A_i=diag(c_{i_1,1},\dots ,c_{i_d,d}),$$

where $i=(i_1,\dots ,i_d)$. For each multi-index ℓ, we can now define the quasi-interpolant anisiotropically:

$$Q_{\ell }f\left(x\right)=\sum _{x_{\ell ,i}\in {\mathbb{G}}_{\ell }}f\left(x_{\ell ,i}\right){\varphi }_c\left(A_i^{-1}(x-x_{\ell ,i})\right),x\in \Omega .$$

(3)

Here, we consider the Gaussian kernel

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

with c determining the degree of smoothness of the interpolant.

To construct the quasi-sparse kernel-based interpolant on the sparse grid ${\tilde{\mathbb{G}}}_{n,d}$, the anisotropic interpolants on the sub-grids ${\mathbb{G}}_{\ell }$ must be linearly combined using the following formula:

$$Q_{n,d}f\left(x\right)=\sum _{j=0}^{d-1}{(-1)}^j\left({\displaystyle \genfrac{}{}{0pt}{}{d-1}{j}}\right)\sum _{|\ell |=n+(d-1)-j}{Q}_{\ell }f\left(x\right).$$

(4)

For example, the quasi-sparse kernel-based interpolation for $d=2$ would be

$$Q_{n,2}f\left(x\right)=\sum _{|\ell |=n+1}{Q}_{\ell }f\left(x\right)-\sum _{|\ell |=n}{Q}_{\ell }f\left(x\right),$$

and for $d=3$, it would be

$$Q_{n,3}f\left(x\right)=\sum _{|\ell |=n+2}{Q}_{\ell }f\left(x\right)-2\sum _{|\ell |=n+1}{Q}_{\ell }f\left(x\right)+\sum _{|\ell |=n}{Q}_{\ell }f\left(x\right).$$

In a similar fashion, we can construct the quasi-sparse kernel-based interpolation formula for the sparse grids based on Chebyshev points by replacing grids ${\mathbb{G}}_{\ell }$ with ${\mathbb{G}}_{\ell }^c$.

4. Multilevel Quasi-Sparse Interpolation

From the construction of sparse grids, it is obvious that sparse grids from the lower level to the upper level are nested; that is,

$${\tilde{\mathbb{G}}}_{n,d}\subset {\tilde{\mathbb{G}}}_{n+1,d}$$

for all $n\ge 1$. We have illustrated this nested nature in Figure 3 for equally spaced grid points. For Chebysheb points, we have also shown the nested nature of the grids, which is presented in Figure 4. Moreover, while combining kernel-based anisotropic interpolants for each subgrid, they were appropriately scaled, with the scaling being proportional to the density of the corresponding constituent subgrid. One can utilize these nested properties of the subgrids to propose a multilevel method of interpolation with them without adding any further complexity to the quasi-sparse kernel-based interpolation introduced earlier. In the earlier literature [8,9,10], multilevel methods for radial basis functions were used to combine stationary and non-stationary interpolants to accelerate convergence and to improve the numerical stability of ill-conditioned problems.

The main idea of multilevel sparse grid-based quasi-interpolation is to interpolate the function at the lowest level, that is, for $n=1$, and then update at each level of the sub-grids by computing the residuals at every level, interpolating them at the higher level. More formally, we obtain the quasi-sparse kernel-based interpolation $Q_{n_0,d}f\left(x\right)$ at the coarsest level 1; that is, the coarsest level approximation is $S_{0,d}f\left(x\right)=Q_{n_0,d}u\left(x\right)$. Then, we define the residual function at level j as $r_j\left(x\right)=f\left(x\right)-S_{j-1,d}f\left(x\right)$ and interpolate the residual function as

$${\Delta }_j\left(x\right)=Q_{n_0+j,d}{r}_j\left(x\right)$$

on the level $n_0+j$ sparse grid ${\tilde{\mathbb{G}}}_{n_0+j,d}$ and then update the multilevel interpolant as follows:

$$S_{j,d}f\left(x\right)=S_{j-1,d}f\left(x\right)+{\Delta }_j\left(x\right),\mathrm{for}1\le j\le n.$$

We refer to this algorithm as the multilevel quasi-sparse kernel-based interpolation. As the quasi-sparse kernel-based interpolation is being used at every level, the time–complexity of the multilevel method is linear with these levels. However, it takes more time than the usual quasi-sparse interpolation for a fixed level as it evaluates the residuals at every grid point. Again, the algorithm is easily amenable to parallel computing.

5. Implementation

In this article, all algorithms and numerical experiments are implemented in MATLAB software 23.2. This is necessary to be done, otherwise it will affect publication. environment. The implementation is broken down into three main parts:

• Creating sparse grids using either equally spaced grids or Chebyshev points for each level of the multilevel grid;
• Anisotropic quasi-interpolation $Q_{\ell }f\left(x\right)$ using a Gaussian kernel;
• The development of an algorithm for quasi-sparse interpolation, which combines anisotropic quasi-interpolants, as described earlier.

For multilevel quasi-interpolation, we implement another function to apply the algorithm.

Multilevel Quasi-Sparse Interpolation

The outline for the algorithm of multilevel quasi-sparse interpolation is given in Algorithm 1. In the implementation of the multilevel quasi-sparse interpolation, after initial checks and creating a sparse grid of points, if necessary, we compute the quasi-interpolation approximation using the function QSIK for level $n=1$. For all other levels $i>1$, we evaluate the quasi-sparse interpolation approximation at all sparse grid points and then subtract that from the original function value to compute the residual function and then again compute the quasi-sparse approximation for the residual function at level i and add that estimate to the function approximation, where we already have up to level i. We continue computing the residual functions and updating our approximation at each level until the maximum level of evaluation n is reached. This multilevel approximation returns the function approximations at all levels $1\le i\le n$. Though it requires a lot of quasi-sparse interpolation approximations at all levels, we can reduce the computation time by computing the function approximations at all levels together rather than calling the function separately for each level.

Algorithm 1: Multilevel Quasi-Sparse Interpolation Algorithm
Data: Sparse grid data decomposition
Result: The multilevel quasi-sparse interpolation $S_{n,d}f\left(x\right)$.
1. Initialize the first interpolation value at zero, that is $S_{0,d}f\left(x\right)=0$.
2. Construct the nested sparse grids as ${\tilde{\mathbb{G}}}_{j,d}\subset {\tilde{\mathbb{G}}}_{j+1,d}$.
3. for $j=1,\dots ,n$ do
	Compute $r_j\left(x\right)=f\left(x\right)-S_{j-1,d}f\left(x\right)$ for all $x\in {\tilde{\mathbb{G}}}_{j,d}$;
	Compute ${\Delta }_j\left(x\right)=Q_{j,d}{r}_j\left(x\right)$ using Algorithm described in Section 4;
	Update $S_{j,d}f\left(x\right)=S_{j-1,d}f\left(x\right)+{\Delta }_j\left(x\right)$.
end

6. Numerical Experiments for Quasi-Sparse Interpolation with $\mathit{d}=\mathbf{2}$

We now illustrate the performance of the proposed quasi-sparse kernel-based interpolation for the following test functions:

• $F_1^{2d}(x,y)$ (Franke’s function)

  $$\begin{array}{ccc}\hfill F_1^{2d}(x,y)& =& 0.75e^{-({(9x-2)}^2+{(9y-2)}^2)/4}+0.75e^{-{(9x+1)}^2/49-{(9y+1)}^2/10}\hfill \\ & & +0.5e^{-({(9x-7)}^2+{(9y-3)}^2)/4}-0.2e^{-({(9x-4)}^2+{(9y-7)}^2)}.\hfill \end{array}$$
• $F_2^{2d}(x,y)=(1-x^2)(1-y^2)$.
• $F_3^{2d}(x,y)=\sqrt{{\displaystyle \frac{18}{\pi }}}{e}^{-(x^2+81y^2)}$.
• $F_4^{2d}(x,y)={\displaystyle \frac{1.25+cos\left(5.4y\right)}{6+6{(3x-1)}^2}}$.

Franke’s function is very commonly used as a test function in the interpolation literature with RBF kernels [11]. The others can be found in [12,13,14], respectively. These test functions are illustrated in Figure 5.

In all of these numerical experiments, we have used a $50\times 50$ uniform grid of points in the rectangle $[-1,1]\times$ $[-1,1]$. The error in approximation is reported as the maximum modulus error; that is, $\parallel f-Q_{n,d}f\parallel$, and root mean square error is defined as follows:

$$\sqrt{{\displaystyle \frac{1}{N_e}}{\displaystyle \sum _{i=1}^n}{(f\left(x_i\right)-Q_{n,d}f\left(x_i\right))}^2},$$

where $x_i$$i=1,\dots ,N_e$ are the evaluation points, and $N_e$ is the total number of evaluation points. We also report the number of points in the sparse grid ${\tilde{G}}_{n,d}$ (or ${\tilde{G}}_{n,d}^c$) as SGnode and the number of points actually used in the computation as some of the points are revisited in the sparse grid computations as DoF.

Figure 6 shows the approximation using our proposed quasi-sparse kernel-based interpolation with an equally spaced grid ${\tilde{\mathbb{G}}}_{n,2}$ for different values of n.

Table 1. Quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev point grid results for the test function $F_1^{2d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
9	9	0.92616	0.24884	0.018	0.89474	0.231770	0.0179
21	39	0.92911	0.24940	0.025	0.91436	0.233400	0.024
49	109	0.88190	0.23617	0.047	0.76886	0.180060	0.048
113	271	0.86792	0.23205	0.079	0.64397	0.132990	0.076
257	641	0.82000	0.22755	0.149	0.55427	0.103100	0.145
577	1475	0.80022	0.22624	0.313	0.43634	0.070535	0.292
1281	3333	0.78678	0.22575	0.664	0.30363	0.043283	0.682
2817	7431	0.78586	0.22560	1.401	0.18151	0.024121	1.305
6145	16,393	0.77768	0.22554	2.822	0.09293	0.012131	2.678
13,313	35,851	0.78174	0.22553	5.536	0.04147	0.005629	5.116

also shows the error estimates. We observe that the maximum error or the RMS error does not decrease substantially as we increase the sparse grid level n, but the plots show that approximations are very close to the true function $F_1^{2d}$ for $n>6$. With Chebyshev points, we observe much better approximations with both the maximum error and the RMS error decreasing with the increase in level n. The plots of the interpolating function evaluated at the $50\times 50$ grid points for the algorithm with Chebyshev points are shown in Figure 7. Again, we observe that the approximations are quite good for $n>6$.

Figure 8 shows the approximations using our proposed quasi-sparse kernel-based interpolation with equally spaced grids ${\tilde{\mathbb{G}}}_{n,2}$ for different values of n for the test function $F_2^{2d}(x,y)$.

Table 2. Quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev point grid results for the test function $F_2^{2d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
9	9	0.84805	0.45491	0.018	0.8409	0.41803	0.017
21	39	0.77623	0.41629	0.028	0.8236	0.38014	0.023
49	109	0.75404	0.40043	0.072	0.5678	0.25995	0.050
113	271	0.75256	0.39481	0.085	0.4225	0.17896	0.079
257	641	0.75263	0.39297	0.186	0.2591	0.10923	0.141
577	1475	0.74977	0.39240	0.375	0.1347	0.05796	0.298
1281	3333	0.75337	0.39223	0.683	0.0593	0.02757	0.648
2817	7431	0.74458	0.39218	1.294	0.0229	0.01259	1.321
6145	16,393	0.74666	0.39217	2.749	0.0096	0.00589	2.667
13,313	35,851	0.75301	0.39216	5.027	0.0045	0.00290	5.115

also shows the error estimates. We observe that the maximum error or the RMS error does not decrease substantially as we increase the grid level n, but the plots show that approximations are very close to the true function $F_2^{2d}$ for $n>2$ when we use equally spaced grids. With Chebyshev points, we observe much better approximations, with both the maximum error and the RMS error decreasing with the level n. The plots of the interpolating function evaluated at $50\times 50$ grid points for the algorithm with Chebyshev points are shown in Figure 9. For $n=1$, the approximations are poor, but it approximates nicely as n increases. On the other hand, when there are equally spaced grids, the interpolant starts to overfit the surface and lacks smoothness for larger values of n. Thus, by increasing the number of grid levels, the approximation actually deteriorates for equally spaced grids.

Figure 10 shows the approximations using our proposed quasi-sparse kernel-based interpolation with equally spaced grids ${\tilde{\mathbb{G}}}_{n,2}$ for different values of n for the test function $F_3^{2d}(x,y)$.

Table 3. Quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev point grid results for the test function $F_3^{2d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
9	9	1.97480	0.40313	0.016	1.8427	0.48854	0.017
21	39	1.93230	0.37292	0.024	1.9868	0.45415	0.022
49	109	1.91530	0.36748	0.048	1.6822	0.39947	0.051
113	271	1.88590	0.37309	0.073	1.4987	0.34353	0.078
257	641	1.83230	0.36540	0.141	1.1621	0.25966	0.142
577	1475	1.80050	0.36168	0.308	0.8929	0.16772	0.300
1281	3333	1.79530	0.36006	0.626	0.6563	0.10807	0.682
2817	7431	1.78100	0.35929	1.319	0.3949	0.06122	1.325
6145	16,393	1.78460	0.35987	2.616	0.1928	0.03013	2.674
13,313	35,851	1.79160	0.36007	5.084	0.0797	0.01421	5.113

shows the error estimates. We observe that the maximum error or the RMS error does not decrease substantially as we increase the grid level n, but the plots show that approximations are very close to the true function $F_3^{2d}$ for $n>4$ when we use equally spaced grids. With Chebyshev points, we observe much better approximations, with both the maximum error and the RMS error decreasing with the level n. The plots of the interpolating function evaluated at $50\times 50$ grid points for the algorithm with Chebyshev points are shown in Figure 11. For $n=1$, the approximations are poor, and the overall shape is not similar to the shape of the function, but it approximates nicely as n increases. On the other hand, when there are equally spaced grids, the interpolant starts to overfit the surface and lacks smoothness for larger values of n. Thus, by increasing the number of grid levels, the approximation actually deteriorates for equally spaced grids.

Figure 12 shows the approximations using our proposed quasi-sparse kernel-based interpolation with equally spaced grids ${\tilde{\mathbb{G}}}_{n,2}$ for different values of n for the test function $F_4^{2d}(x,y)$.

Table 4. Quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev point grid results for the test function $F_4^{2d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
9	9	0.33863	0.08989	0.019	0.2952	0.07502	0.019
21	39	0.31804	0.08456	0.023	0.3350	0.08348	0.021
49	109	0.29950	0.08309	0.059	0.2294	0.05323	0.044
113	271	0.29077	0.08263	0.091	0.1873	0.04437	0.073
257	641	0.28290	0.08220	0.146	0.1491	0.03358	0.146
577	1475	0.28154	0.08200	0.299	0.1084	0.02364	0.299
1281	3333	0.28141	0.08192	0.615	0.0671	0.01448	0.748
2817	7431	0.27816	0.08187	1.372	0.0396	0.00817	1.339
6145	16,393	0.27869	0.08187	2.632	0.0305	0.00467	2.664
13,313	35,851	0.27887	0.08187	5.023	0.0265	0.00315	5.177

shows the error estimates. We observe that the maximum error or the RMS error does not decrease substantially as we increase the grid level n, but the plots show that approximations are very close to the true function $F_4^{2d}$ for $n>4$ when we use equally spaced grids. With Chebyshev points, we observe much better approximations, with both the maximum error and the RMS error decreasing with the level n. The plots of the interpolating function evaluated at $50\times 50$ grid points for the algorithm with Chebyshev points are shown in Figure 13. For $n=2$, the approximations are poor, and the overall shape is not similar to the shape of the function, but it approximates nicely as n increases.

In these results, quasi-sparse interpolation with equally space grids reaches a stable maximum absolute error and root mean square errors at a lower level with a small number of sparse grid points. However, the quasi-sparse interpolation with Chebyshev points attains much smaller values for maximum errors and RMS errors for all test functions and stabilizes for larger values of the level n. Additionally, since the errors remain stable when the number of grid points increases, the quasi-sparse interpolation goes well with the multilevel quasi-sparse algorithm, which will be examined in a subsequent sub-section. The main observation in these results is that quasi-sparse interpolation does not converge for equally spaced grids, but it does converge for Chebyshev grid points. The rate of convergence depends on the test function.

7. Numerical Experiments for Quasi-Sparse Interpolations with $\mathit{d}=\mathbf{3}$

In this section, we present the performance analysis for some test functions with domain $\Omega =$ ${[-1,1]}^3$ in dimension $d=3$. The following functions are used as test functions:

• $F_1^{3d}(x,y)$ (Franke’s function)

  $$\begin{array}{ccc}\hfill F_1^{3d}(x,y)& =& 0.75e^{-({(9x-2)}^2+{(9y-2)}^2+{(9z-2)}^2)/4}+0.75e^{-{(9x+1)}^2/49-{(9y+1)}^2/10-{(9z+1)}^2/10}\hfill \\ & & +0.5e^{-({(9x-7)}^2+{(9y-3)}^2+{(9z-5)}^2)/4}-0.2e^{-({(9x-4)}^2+{(9y-7)}^2+{(9z-5)}^2)}.\hfill \end{array}$$
• $F_2^{3d}(x,y)=(1-x^2)(1-y^2)(1-z^2)$.
• $F_3^{3d}(x,y)=\sqrt{{\displaystyle \frac{18}{\pi }}}{e}^{-(x^2+81y^2+z^2)}$.
• $F_4^{3d}(x,y)=cos\left(6z\right){\displaystyle \frac{1.25+cos\left(5.4y\right)}{6+6{(3x-1)}^2}}$.

The performance of our quasi-sparse kernel-based interpolant is evaluated in a grid of $20\times 20\times 20$ equally spaced points in the cube ${[-1,1]}^3$. The results are summarised in

Table 5. Quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev point grid results for the test function $F_1^{3d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
27	27	0.82746	0.11080	0.051	0.8143	0.10688	0.444
81	162	0.83700	0.11181	0.168	0.8221	0.10694	0.168
225	630	0.83172	0.10873	0.552	0.7755	0.09306	0.553
593	1997	0.82756	0.10771	1.647	0.7349	0.08037	1.608
1505	5687	0.80391	0.10663	4.165	0.7023	0.06938	4.117
3713	15,188	0.79746	0.10614	10.798	0.6484	0.05622	10.655
8961	38,868	0.77528	0.10574	26.174	0.5836	0.04364	25.607

,

Table 6. Quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev point grid results for the test function $F_2^{3d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
27	27	0.9365	0.34503	0.055	0.9365	0.32901	0.045
81	162	0.8978	0.33059	0.217	0.9262	0.31016	0.171
225	630	0.8802	0.32260	0.557	0.7728	0.25254	0.560
593	1997	0.8733	0.31900	1.630	0.6776	0.20495	1.616
1505	5687	0.8708	0.31756	4.172	0.5138	0.15122	4.154
3713	15,188	0.8699	0.31703	10.468	0.3677	0.10426	10.389
8961	38,868	0.8697	0.31684	25.953	0.2402	0.06723	25.705

,

Table 7. Quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev point grid results for the test function $F_3^{3d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
27	27	2.2099	0.32267	0.046	2.0758	0.33152	0.045
81	162	2.1726	0.31437	0.169	2.2421	0.32432	0.183
225	630	2.1558	0.31386	0.559	1.8688	0.29868	0.555
593	1997	2.1364	0.31547	1.625	1.7660	0.27446	1.614
1505	5687	2.1096	0.31310	4.150	1.4888	0.22923	4.176
3713	15,188	2.0936	0.31163	10.760	1.2753	0.17821	10.662
8961	38,868	2.0862	0.31130	25.750	1.0220	0.13504	25.441

and

Table 8. Quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev point grid results for the test function $F_4^{3d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
27	27	0.3849	0.07847	0.045	0.4322	0.09322	0.042
81	162	0.3662	0.07535	0.202	0.3769	0.07620	0.166
225	630	0.3578	0.07125	0.583	0.4280	0.07657	0.543
593	1997	0.3394	0.06952	1.647	0.3923	0.06564	1.616
1505	5687	0.3339	0.06877	4.163	0.3448	0.05411	4.116
3713	15,188	0.3282	0.06837	10.471	0.3018	0.04450	10.294
8961	38,868	0.3249	0.06827	25.972	0.2531	0.03517	25.899

. Due to the long computing time and the unavailability of a parallel computing environment, we evaluate only $n=7$ levels for the multilevel algorithm. The results are similar to our observation for the numerical experiments in $d=2$ as we do not observe any convergence of the quasi-sparse interpolation with equally spaced grids, but the approximations converge for Chebyshev points in all test functions.

8. Numerical Experiments for Multilevel Quasi-Sparse Interpolation

In this section, we illustrate the performance of our proposed multilevel quasi-sparse kernel b-sed interpolation method for the same test functions, $F_1^{2d}$, $F_2^{2d}$, $F_3^{2d}$, and $F_4^{2d}$, as introduced earlier. We evaluate the interpolations at a grid of $50\times 50$ points in the rectangle $[-1,1] \times [-1,1]$. The results are shown in

Table 9. Multilevel quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev grid results for the test function $F_1^{2d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
9	9	0.92616	0.24884	0.009	0.89474	0.23177	0.011
21	39	0.83928	0.21052	0.042	0.79237	0.19255	0.043
49	109	0.73335	0.16992	0.078	0.66953	0.15399	0.075
113	271	0.64322	0.13556	0.158	0.52317	0.10671	0.161
257	641	0.5213	0.10474	0.342	0.43208	0.07463	0.350
577	1475	0.4117	0.07972	0.865	0.33932	0.04972	0.789
1281	3333	0.3143	0.06017	2.569	0.22871	0.03020	2.321
2817	7431	0.2393	0.04526	7.121	0.11902	0.01538	7.031
6145	16,393	0.1799	0.03400	25.948	0.04341	0.00589	26.286
13,313	35,851	0.1361	0.02553	103.060	0.01552	0.00155	104.900

,

Table 10. Multilevel quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev grid results for the test function $F_2^{2d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
9	9	0.8409	0.45491	0.009	0.8481	0.41803	0.009
21	39	0.6510	0.36356	0.043	0.6838	0.31352	0.039
49	109	0.4929	0.27946	0.080	0.4557	0.19141	0.079
113	271	0.3731	0.21150	0.172	0.2341	0.09706	0.158
257	641	0.2813	0.15917	0.341	0.0856	0.03728	0.349
577	1475	0.2130	0.11955	0.862	0.0278	0.01046	0.812
1281	3333	0.1596	0.08974	2.274	0.0087	0.00236	2.229
2817	7431	0.1196	0.06735	7.312	0.0038	0.00075	7.041
6145	16,393	0.0904	0.05054	26.093	0.0028	0.00034	26.036
13,313	35,851	0.0675	0.03793	104.410	0.0012	0.00015	106.930

,

Table 11. Multilevel quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev grid results for the test function $F_3^{2d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
9	9	1.97480	0.40313	0.009	1.8427	0.48854	0.009
21	39	1.60630	0.35940	0.044	1.4970	0.56101	0.041
49	109	1.31510	0.30034	0.080	1.3375	0.50115	0.074
113	271	1.06830	0.24349	0.159	1.1287	0.38064	0.195
257	641	0.83075	0.18909	0.375	0.8010	0.26008	0.332
577	1475	0.63185	0.14348	0.866	0.5141	0.12958	0.805
1281	3333	0.47352	0.10812	2.259	0.2914	0.05399	2.226
2817	7431	0.35422	0.08115	7.053	0.1212	0.01992	6.980
6145	16,393	0.26586	0.06086	26.270	0.0339	0.00579	31.276
13,313	35,851	0.19815	0.04569	104.750	0.0065	0.00116	104.840

and

Table 12. Multilevel quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev grid results for the test function $F_4^{2d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
9	9	0.3386	0.08989	0.011	0.2952	0.07502	0.025
21	39	0.2906	0.07151	0.043	0.2692	0.06758	0.038
49	109	0.2348	0.05599	0.101	0.1914	0.05441	0.109
113	271	0.1847	0.04338	0.162	0.1257	0.04157	0.227
257	641	0.1407	0.03316	0.345	0.1080	0.02857	0.332
577	1475	0.1068	0.02514	0.880	0.0690	0.01629	0.886
1281	3333	0.0811	0.01900	2.230	0.0317	0.00701	2.396
2817	7431	0.0615	0.01434	7.056	0.0104	0.00223	7.005
6145	16,393	0.0477	0.01082	25.989	0.0024	0.00029	25.746
13,313	35,851	0.0370	0.00817	107.280	0.0008	0.00009	104.010

for the test functions in $d=2$. Some of the approximate functions are also plotted in Figure 14, Figure 15, Figure 16, Figure 17, Figure 18, Figure 19, Figure 20 and Figure 21. For both equally spaced sparse grids and Chebyshev point-based sparse grids, we observe that the maximum error and the root mean square error decrease with the increase in level n. The multilevel quasi-sparse interpolation results are even better with Chebyshev points instead of equally spaced grids.

Next, we illustrate the application of our multilevel quasi-sparse interpolation with a Gaussian kernel for the test functions $F_1^{3d}$, $F_2^{3d}$, $F_3^{3d}$, and $F_4^{3d}$ in dimension $d=3$, as introduced earlier. For $d=3$, we evaluate the multilevel interpolation using a grid of $20\times 20\times 20$ points in the cube ${[-1,1]}^3$.

Table 13. Multilevel quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev grid results for the test function $F_1^{3d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
27	27	0.82746	0.11080	0.040	0.8143	0.10688	0.037
81	162	0.80642	0.10328	0.236	0.7753	0.09751	0.241
225	630	0.78322	0.09384	0.801	0.7306	0.08611	0.821
593	1997	0.75882	0.08465	2.480	0.6650	0.07091	2.469
1505	5687	0.71458	0.07554	8.196	0.6213	0.05736	8.085
3713	15,188	0.66788	0.06704	30.099	0.5785	0.04466	29.483
8961	38,868	0.60584	0.05910	128.210	0.5211	0.03287	127.010

,

Table 14. Multilevel quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev grids results for the test function $F_2^{3d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
27	27	0.9365	0.34503	0.041	0.9365	0.32901	0.049
81	162	0.8405	0.31540	0.202	0.8602	0.28440	0.201
225	630	0.7393	0.28145	0.782	0.7125	0.21744	0.783
593	1997	0.6451	0.24828	2.514	0.5097	0.14621	2.475
1505	5687	0.5636	0.21794	8.222	0.3128	0.08456	8.113
3713	15,188	0.4938	0.19096	29.847	0.1556	0.04162	29.519
8961	38,868	0.4335	0.16720	128.580	0.0600	0.01689	126.620

,

Table 15. Multilevel quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev grid results for the test function $F_3^{3d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
27	27	2.2099	0.32267	0.039	2.0758	0.33152	0.037
81	162	2.0083	0.29220	0.237	1.9006	0.35681	0.204
225	630	1.8151	0.26318	0.833	1.6722	0.36067	1.108
593	1997	1.6279	0.23656	2.493	1.3596	0.32133	2.630
1505	5687	1.4391	0.20954	8.325	1.0261	0.25248	8.110
3713	15,188	1.2623	0.18412	29.474	0.7688	0.16061	29.341
8961	38,868	1.1086	0.16129	130.150	0.5329	0.08978	127.010

and

Table 16. Multilevel quasi-sparse interpolation with a Gaussian kernel using equally spaced grids and Chebyshev grid results for the test function $F_4^{3d}$.

SGnodes	DoFs	Equal			Chebyshev
		Max Error	RMS Error	Time	Max Error	RMS Error	Time
27	27	0.3849	0.07847	0.064	0.4322	0.09322	0.064
81	162	0.3815	0.07424	0.252	0.4136	0.08504	0.207
225	630	0.3697	0.06821	0.805	0.4424	0.08104	0.777
593	1997	0.3409	0.06137	2.488	0.4245	0.06963	2.491
1505	5687	0.3097	0.05468	8.152	0.3540	0.05359	8.124
3713	15,188	0.2746	0.04841	29.676	0.2721	0.04173	29.474
8961	38,868	0.2425	0.04275	128.450	0.1914	0.03210	126.960

show the error estimates with maximum absolute error and root mean square errors for the proposed interpolant for levels up to $n=7$. Again, we observe that the errors decrease with the level n for the multilevel procedure for both equally spaced grids and Chebyshev points. However, errors are much smaller for Chebyshev points at higher levels.

9. Convergence with Computation Time

In Figure 22, the root mean square (RMS) error is plotted against the computation time for the same test functions in $d=2$, and similar plots of RMS error against time for the test functions in $d=3$ are plotted in Figure 23. These figures show that the quasi-sparse interpolation with equally spaced grids does not converge in error as computational time increases. On the other hand, the errors decrease quite fast and converge for quasi-sparse interpolation with Chebyshev points. Multilevel quasi-sparse interpolation with an equally spaced grid improves errors in approximation and shows some convergence. Still, Chebyshev points present much better convergence results than equally spaced points. It is also interesting to note that, at a similar computational time (in seconds), quasi-sparse interpolation with Chebyshev points yields better results than the multilevel method, though multilevel methods execute only at a smaller number of levels at a comparable time.

Figure 23 shows the RMS error in approximation against the computational time (in seconds) for the test functions in dimension $d=3$. Here, we do not observe the convergence in any of the algorithms as all except equally spaced points with quasi-sparse interpolation are show a decreasing trend in errors with computational time. Here, better performance is also obtained for Chebyshev points and Chebyshev points with only quasi-sparse interpolations, which are competitive with multilevel algorithms for a similar computational time and better than multilevel algorithms with equally spaced points.

10. Discussion and Findings

In this article, we explored an algorithm for quasi-interpolation with a Gaussian kernel based on sparse grids. We observed that quasi-sparse kernel-based interpolation approximates two- and three-dimensional functions quite reasonably. However, quasi-interpolation is not guaranteed to converge. We observed that even for large values of the level n of the grids, the root mean square error of the approximation does not converge to 0 if we use equally spaced sparse grids. However, if we use Chebyshev points, the root mean square error of the approximation steadily decreases with level n. We obtain a much better approximation with Chebyshev points than an equally spaced grid for larger values of n. However, Chebyshev points are more dense along the boundary of the domain and more sparse in the centre. For this reason, Chebyshev points yield a very poor approximation in the centre for smaller values of n, which is evident from the plots with Chebyshev approximations with $n=1$ or $n=2$.

The way grids ${\mathbb{G}}_{\ell }$ are constructed, it is possible to implement the algorithm in parallel to make it faster. Otherwise, the repeat of evaluation of the anisotropic interpolant at many grid points for different values of n slows down the execution. We can see that for $d=2$, the level $n=10$ has 13313 distinct points only, but these points are revisited many times, yielding a total number of 35851 points used for computation. This increases the function evaluation by nearly three times. For $d=3$ and the level $n=7$, the number of unique grid points is only 8961, but the points used for computation reach 38868. Due to this, the time–complexity of the algorithm increases by many times; one should either implement the algorithm for parallel computing only or improve the algorithm to avoid revisiting grid points for different multi-index ℓ.

In this article, we also proposed multilevel quasi-sparse kernel-based interpolation based on equally spaced grids as well as sparse grids based on Chebyshev points. We illustrated our proposed methods using some numerical test functions. We observed that the proposed multilevel quasi-procedure performs better than the proposed quasi-sparse interpolation method. However, the computational time for the multilevel method is considerably higher than for simple quasi-sparse interpolation. This is because the multilevel method requires residual functions to be evaluated at every sparse grid point, and as the level n increases, the number of sparse grid points also increases exponentially, which leads to a huge increase in computational time. On a positive note, we would like to mention that due to the nature of sparse grid construction, it is possible to implement the algorithm for parallel computing, which will reduce the computational time considerably.

Furthermore, the multilevel quasi-sparse algorithm requires substantially less computational time compared to other multilevel methods proposed in the literature as it does not require solving a system of linear equations at every level of approximations with the residual functions. Due to the implementation of the quasi-sparse algorithm at every level, the proposed multilevel quasi-sparse method will have linear time complexity with the level n.

11. Conclusions

The paper has successfully demonstrated the viability and advantages of using multilevel quasi-interpolation techniques on Chebyshev sparse grids. In comparison to conventional methods, the multilevel quasi-sparse interpolation with Gaussian kernels showed promising performance metrics. This paper also elaborated on the implementation complexities and challenges, providing an efficient way to construct sparse grids and compute anisotropic quasi-interplants. While the methodology was effective in lower dimensions, i.e., two dimensions and three dimensions, limitations began to appear as the computational time and complexity increased, indicating areas for future research and optimisation.

The numerical experiments yielded insightful data on the performance of this technique, showcasing its capacity for faster convergence with computation time in specific settings. The study acts as a foundational resource for future research aiming to employ multilevel quasi-interpolation techniques for various applications, especially in high-dimensional computational problems.