R: Create interpolating function.

ipol {chebpol} | R Documentation

## Create interpolating function.

### Description

Create an interpolating function from given values. Several interpolation methods are supported.

### Usage

    ipol(val, dims = NULL, intervals = NULL, grid = NULL, knots = NULL,
      k = NULL, method = c("chebyshev", "multilinear", "fh", "uniform",
      "general", "polyharmonic", "simplexlinear", "hstalker", "stalker",
      "crbf", "oldstalker"), ...)

### Arguments

`val` | array or function. Function values on a grid, or the function itself. If it is the values, the `"dim"`-attribute must be appropriately set. If it is a function, it will be evaluated in the grid points.
`dims` | integer vector. The number of grid points in each dimension. Not needed if `val` is an array or `grid` is used.
`intervals` | list of length 2 numeric vectors. The lower and upper bound in each dimension. Not used if `grid` is specified.
`grid` | list. Each element is a vector of ordered grid-points for a dimension. These need not be Chebyshev-knots, nor evenly spaced.
`knots` | matrix. Each column is a point in an M-dimensional space.
`k` | numeric. Additional value, used with some methods.
`method` | character. The interpolation method to use.
`...` | Further arguments to the function, if `is.function(val)`. And some extra arguments for interpolant creation described in section Details.

### Details

`ipol` is a wrapper around various interpolation methods in package chebpol. Which arguments to specify depends on the method. The interpolation methods are described in `vignette("chebpol",package="chebpol")`.

The method `"chebyshev"` needs only the number of Chebyshev knots in each dimension. This is either the `"dim"` attribute of the array `val`, or the `dims` argument if `val` is a function. Also the intervals can be specified if different from [-1, 1].

The method `"uniform"` is similar to the `"chebyshev"`, but uniformly spaced knots are created. The argument `intervals` generally goes with `dims` when something else than standard intervals `[-1, 1]` are used.

The methods `"multilinear"`, `"fh"` (Floater-Hormann), `"stalker"`, `"hstalker"`, and `"general"` needs the argument `grid`. These are the methods which can use arbitrary Cartesian grids. The stalker spline is described in `vignette("stalker",package="chebpol")`. The Floater-Hormann method (`"fh"`) also needs the `k` argument, the degree of the blending polynomials. It defaults to 4.

The method `"polyharmonic"` needs the arguments `knots` and `k`. In addition it can take the logical argument `normalize` for normalizing the knots to the unit hypercube. The default is `NA`, which uses normalization if any of the knots are outside the unit hypercube. Also, a logical `nowarn` is accepted, it is used to suppress a warning in case the system can't be solved exactly and a least squares fallback method is used.

The method `"simplexlinear"` needs the argument `knots`. It creates a Delaunay triangulation from the knots, and does linear interpolation in each simplex by weighting the vertex values with the barycentric coordinates.

If knots are required, but the grid argument is given, knots are constructed as `t(expand.grid(grid))`

The `"crbf"` is the multilayer compact radial basis function interpolation in ALGLIB (http://www.alglib.net/interpolation/fastrbf.php). It is only available if ALGLIB was available at compile time. It takes the extra arguments `"rbase"`, `"layers"`, and `"lambda"`. These are discussed in the ALGLIB documentation.

There are also some usage examples and more in `vignette("chebpol")` and `vignette('chebusage')`.

### Value

A `function(x, threads=getOption('chebpol.threads'))` defined on a hypercube, an interpolant for the given function. The argument `x` can be a matrix of column vectors which are evaluated in parallel in a number of threads. The function yields values for arguments outside the hypercube as well, though it will typically be a poor approximation. `threads` is an integer specifying the number of parallel threads which should be used when evaluating a matrix of column vectors.

### Examples

    ## evenly spaced grid-points
    su <- seq(0,1,length.out=10)
    ## irregularly spaced grid-points
    s <- su^3
    ## create approximation on the irregularly spaced grid
    ml1 <- ipol(exp, grid=list(s), method='multilin')
    fh1 <- ipol(exp, grid=list(s), method='fh')
    ## test it, since exp is convex, the linear approximation lies above
    ## the exp between the grid points
    ml1(su) - exp(su)
    fh1(su) - exp(su)

    ## multi dimensional approximation
    f <- function(x) 10/(1+25*mean(x^2))
    # a 3-dimensional 10x10x10 grid, first and third coordinate are non-uniform
    grid <- list(s, su, sort(1-s))

    # make multilinear, Floater-Hormann, Chebyshev and polyharmonic spline.
    ml2 <- ipol(f, grid=grid, method='multilin')
    fh2 <- ipol(f, grid=grid, method='fh')
    hst <- ipol(f, grid=grid, method='hstalker')
    ch2 <- ipol(f, dims=c(10,10,10), intervals=list(0:1,0:1,0:1), method='cheb')
    knots <- matrix(runif(3*1000),3)
    ph2 <- ipol(f, knots=knots, k=2, method='poly')
    sl2 <- ipol(f, knots=knots, method='simplexlinear')
    # my alglib is a bit slow, so stick to 100 knots
    if(havealglib()) crb <- ipol(f, knots=knots[,1:100], method='crbf',
      rbase=2, layers=5, lambda=0)
    # make 7 points in R3 to test them on
    m <- matrix(runif(3*7),3)
    rbind(true=apply(m,2,f), ml=ml2(m), fh=fh2(m), cheb=ch2(m), poly=ph2(m), sl=sl2(m),hst=hst(m),
    crbf=if(havealglib()) crb(m) else NULL )

[Package chebpol version 2.1-2 Index]