approxfun {stats} | R Documentation |

## Interpolation Functions

### Description

Return a list of points which linearly interpolate given data points, or a function performing the linear (or constant) interpolation.

### Usage

```
approx (x, y = NULL, xout, method = "linear", n = 50,
yleft, yright, rule = 1, f = 0, ties = mean, na.rm = TRUE)
approxfun(x, y = NULL, method = "linear",
yleft, yright, rule = 1, f = 0, ties = mean, na.rm = TRUE)
```

### Arguments

`x` , `y` |
numeric vectors giving the coordinates of the points to be
interpolated. Alternatively a single plotting structure can be
specified: see |

`xout` |
an optional set of numeric values specifying where interpolation is to take place. |

`method` |
specifies the interpolation method to be used. Choices
are |

`n` |
If |

`yleft` |
the value to be returned when input |

`yright` |
the value to be returned when input |

`rule` |
an integer (of length 1 or 2) describing how interpolation
is to take place outside the interval [ |

`f` |
for |

`ties` |
handling of tied |

`na.rm` |
logical specifying how missing values ( |

### Details

The inputs can contain missing values which are deleted (if `na.rm`

is true, i.e., by default), so at least
two complete `(x, y)`

pairs are required (for ```
method =
"linear"
```

, one otherwise). If there are duplicated (tied) `x`

values and `ties`

contains a function it is applied to the `y`

values for each distinct `x`

value to produce `(x,y)`

pairs
with unique `x`

.
Useful functions in this context include `mean`

,
`min`

, and `max`

.

If `ties = "ordered"`

the `x`

values are assumed to be already
ordered (and unique) and ties are *not* checked but kept if present.
This is the fastest option for large `length(x)`

.

If `ties`

is a `list`

of length two, `ties[[2]]`

must be a function to be applied to ties, see above, but if
`ties[[1]]`

is identical to `"ordered"`

, the `x`

values
are assumed to be sorted and are only checked for ties. Consequently,
`ties = list("ordered", mean)`

will be slightly more efficient than
the default `ties = mean`

in such a case.

The first `y`

value will be used for interpolation to the left and the last
one for interpolation to the right.

### Value

`approx`

returns a list with components `x`

and `y`

,
containing `n`

coordinates which interpolate the given data
points according to the `method`

(and `rule`

) desired.

The function `approxfun`

returns a function performing (linear or
constant) interpolation of the given data points. For a given set of
`x`

values, this function will return the corresponding
interpolated values. It uses data stored in its environment when it
was created, the details of which are subject to change.

### Warning

The value returned by `approxfun`

contains references to the code
in the current version of **R**: it is not intended to be saved and
loaded into a different **R** session. This is safer for **R** >= 3.0.0.

### References

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)
*The New S Language*.
Wadsworth & Brooks/Cole.

### See Also

`spline`

and `splinefun`

for spline
interpolation.

### Examples

```
require(graphics)
x <- 1:10
y <- rnorm(10)
par(mfrow = c(2,1))
plot(x, y, main = "approx(.) and approxfun(.)")
points(approx(x, y), col = 2, pch = "*")
points(approx(x, y, method = "constant"), col = 4, pch = "*")
f <- approxfun(x, y)
curve(f(x), 0, 11, col = "green2")
points(x, y)
is.function(fc <- approxfun(x, y, method = "const")) # TRUE
curve(fc(x), 0, 10, col = "darkblue", add = TRUE)
## different extrapolation on left and right side :
plot(approxfun(x, y, rule = 2:1), 0, 11,
col = "tomato", add = TRUE, lty = 3, lwd = 2)
### Treatment of 'NA's -- are kept if na.rm=FALSE :
xn <- 1:4
yn <- c(1,NA,3:4)
xout <- (1:9)/2
## Default behavior (na.rm = TRUE): NA's omitted; extrapolation gives NA
data.frame(approx(xn,yn, xout))
data.frame(approx(xn,yn, xout, rule = 2))# -> *constant* extrapolation
## New (2019-2020) na.rm = FALSE: NA's are "kept"
data.frame(approx(xn,yn, xout, na.rm=FALSE, rule = 2))
data.frame(approx(xn,yn, xout, na.rm=FALSE, rule = 2, method="constant"))
## NA's in x[] are not allowed:
stopifnot(inherits( try( approx(yn,yn, na.rm=FALSE) ), "try-error"))
## Give a nice overview of all possibilities rule * method * na.rm :
## ----------------------------- ==== ====== =====
## extrapolations "N":= NA; "C":= Constant :
rules <- list(N=1, C=2, NC=1:2, CN=2:1)
methods <- c("constant","linear")
ry <- sapply(rules, function(R) {
sapply(methods, function(M)
sapply(setNames(,c(TRUE,FALSE)), function(na.)
approx(xn, yn, xout=xout, method=M, rule=R, na.rm=na.)$y),
simplify="array")
}, simplify="array")
names(dimnames(ry)) <- c("x = ", "na.rm", "method", "rule")
dimnames(ry)[[1]] <- format(xout)
ftable(aperm(ry, 4:1)) # --> (4 * 2 * 2) x length(xout) = 16 x 9 matrix
## Show treatment of 'ties' :
x <- c(2,2:4,4,4,5,5,7,7,7)
y <- c(1:6, 5:4, 3:1)
(amy <- approx(x, y, xout = x)$y) # warning, can be avoided by specifying 'ties=':
op <- options(warn=2) # warnings would be error
stopifnot(identical(amy, approx(x, y, xout = x, ties=mean)$y))
(ay <- approx(x, y, xout = x, ties = "ordered")$y)
stopifnot(amy == c(1.5,1.5, 3, 5,5,5, 4.5,4.5, 2,2,2),
ay == c(2, 2, 3, 6,6,6, 4, 4, 1,1,1))
approx(x, y, xout = x, ties = min)$y
approx(x, y, xout = x, ties = max)$y
options(op) # revert 'warn'ing level
```

*stats*version 4.4.1 Index]