Data structures and local Lagrange functions

The first requirement is to structure the data into groups of about q = 30 sites at a time which are relatively close together. The number 30 (sometimes up to 50) is used successfully for q in current thin-plate spline implementations for two or three dimensions. Further, we assume that there is a number q∗ of  data with which we can solve the interpolation system directly and efficiently; this is certainly the case when q∗ is also of the order of 30 points for instance but it may be of the order of a few hundred. Often, one chooses q = q∗. In the simplest case, we can use a standard elimination procedure for solving the linear system such as Gauss-elimination or Cholesk y factorisation if the matrix is positive definite (see our remarks at the beginning of the previous section, and the final section of this chapter).

Since the following method is iterative, it is helpful now to enumerate the finite number of data (which are still assumed to be distinct) as  = {ξ ₁, ξ ₂, . . . , ξ  _m}.

There are various useful ways to distribute the centres in  into several nondisjoint smaller sets. One is as follows. For each k  = 1,2, . . . , m − q∗, we let the set L_{k  consist of ξ k  and those q different points among ξ , where}

 = k +1,k +2, . . . , which minimise the Euclidean distancesξ k −ξ  among

all ξ k +1, ξ k +2, . . . , ξ  m. If there are ties in this minimisation procedure, they are

broken by random choice. The set L_m−q∗₊₁ contains the remaining q∗ points,

that is we let

L_m−q∗₊₁ = {ξ _m−q∗₊₁, ξ _m−q∗₊₂, . . . , ξ  _m}.

As an additional side-condition we also require each of the sets of points to contain a K -unisolvent subset in the sense of Section 5.2, according to which radial basis function is in use, K  being the kernel of the semi-inner product associated with the radial basis function φ. For instance, for two dimensions and the thin-plate splines, K  is the space of linear polynomials and we require an additional linear polynomial. This may alter our above strategy slightly. That this can be done, however, for each of our sets of nearby points is only a small restriction on the  which are admitted. For higher-dimensional problems we

7.2 The BFGP algorithm 169

may have to increase the proposed number q = 30 points for each of the local sets L_{k  when K  has dimension more than 30, but for example for thin-plate}

splines in two dimensions, q = 30 will be sufficient.

One suitable selection is to choose the last dim K  points to be unisolvent, or renumber the points in  accordingly. Then they are included in all L_{k . Three}

points like that are sufficient when thin-plate splines are used in two dimensions. Next, we introduce the central concept of  local Lagrange functions Lloc_k 

associated with L_{k . They are linear combinations}

(7.1) Lloc_k  ( x ) =



ξ ∈L_k 

λk ξ φ( x  − ξ ) + pk ( x ), x  ∈ Rn,

with pk  ∈ K  and with the usual side-conditions on the coefficients not stated

again here, which satisfy the partial cardinality conditions within the L_k 

(7.2) Lloc_k  (ξ _k ) = 1, Lloc_k  |L_{k \{ξ k }}= 0.

Because the cardinality |L_{k | is relatively small, each of the sets of coefficients}

λ_k ξ  can be computed directly and efficiently by a standard method. This is done in advance, before the iterations begin, and this is always the way we proceed in the practical implementation of the algorithm.

The basic idea is now to approximate the interpolant at each step of the main iteration by a linear combination of such local Lagrange functions, in lieu of the true Lagrange functions which would have to satisfy the full Lagrange conditions on the whole set  of centres for the given data and which would, of course, lead to the correct interpolant without any iteration.

Using these approximate Lagrange functions during the iteration, we remain in the correct linear space U  _{which is, by definition, spanned by the translates}

φ( · −ξ ), ξ  ∈ , and contains additionally the semi-norm kernel K . We note that the space U  _{contains in particular the sought interpolant s}∗_{. Because, in}

general, it is true that the local Lagrange functions satisfy

 Lloc_k  |_\L_k = 0,

this produces only a fairly rough approximation to the Lagrange functions. The reduction of the error has to be achieved iteratively by successive correction of  the residuals. Therefore, the corrections of the error come from recursive appli- cation of the algorithm, where at each iteration the sameapproximate Lagrange functions are employed. We note, however, the remarkable fact that it is not even required that | Lloc_k  | restricted to  \ L_{k  be small. Instead, as Faul (2001) shows}

in a re-interpretation of the algorithm we shall present below, the semi-inner products ( ˜ L _jloc, L˜loc_k  )∗ should be small for j = k  for efficiency of the algo-

170 7. Implementations

performed on a positive definite Gram-matrix with such entries which is ex- pected to converge faster, of course, if the off-diagonal elements are small. Here,

˜

 L _jloc are the local Lagrange functions normalised to have semi-norm one, that is ˜

 Lloc _j =  L

loc  j

 L _jloc_∗.

We recall that such a Gram-matrix is always nonnegative definite, and if the gen- erating functions are linearly independent and not in the kernel of the semi-inner product, it is nonsingular. This is the case here, as the local Lagrange functions

˜

 L _jloc, j = 1,2,. . ., are never in K  unless there are as many points as or fewer than dim K , and they are linearly independent by the linear independence of  the translates of the radial basis functions and the cardinality conditions.

We remark already at this point that the algorithm we describe in this section will be an O(m logm) process. This is because we require approximately m of  the local Lagrange functions, each of which requires a small, fixed number of  operations to compute the coefficients – this number is small and independent of m – and because the evaluation of the residuals which is needed at each iteration normally requires O(m logm) computer operations with a suitable scheme being used for large m, such as the one related to the particle methods presented in the next section. In fact, those methods require only O(logm) operations for the needed function evaluation but the set-up cost for the Laurent expansions uses up to O(m logm) operations.