View source: R/functions-binning.R

imputeLinInterpol | R Documentation |

This function provides missing value imputation based on linear
interpolation and resembles some of the functionality of the
`profBinLin`

and `profBinLinBase`

functions deprecated from
version 1.51 on.

```
imputeLinInterpol(
x,
baseValue,
method = "lin",
distance = 1L,
noInterpolAtEnds = FALSE
)
```

`x` |
A numeric vector with eventual missing ( |

`baseValue` |
The base value to which empty elements should be set. This
is only considered for |

`method` |
One of |

`distance` |
For |

`noInterpolAtEnds` |
For |

Values for NAs in input vector `x`

can be imputed using methods
`"lin"`

and `"linbase"`

:

`impute = "lin"`

uses simple linear imputation to derive a value
for an empty element in input vector `x`

from its neighboring
non-empty elements. This method is equivalent to the linear
interpolation in the `profBinLin`

method. Whether interpolation is
performed if missing values are present at the beginning and end of
`x`

can be set with argument `noInterpolAtEnds`

. By default
interpolation is also performed at the ends interpolating from `0`

at the beginning and towards `0`

at the end. For
`noInterpolAtEnds = TRUE`

no interpolation is performed at both
ends replacing the missing values at the beginning and/or the end of
`x`

with `0`

.

`impute = "linbase"`

uses linear interpolation to impute values for
empty elements within a user-definable proximity to non-empty elements
and setting the element's value to the `baseValue`

otherwise. The
default for the `baseValue`

is half of the smallest value in
`x`

(`NA`

s being removed). Whether linear interpolation based
imputation is performed for a missing value depends on the
`distance`

argument. Interpolation is only performed if one of the
next `distance`

closest neighbors to the current empty element has
a value other than `NA`

. No interpolation takes place for
`distance = 0`

, while `distance = 1`

means that the value for
an empty element is interpolated from directly adjacent non-empty
elements while, if the next neighbors of the current empty element are
also `NA`

, it's vale is set to `baseValue`

.
This corresponds to the linear interpolation performed by the
`profBinLinBase`

method. For more details see examples below.

A numeric vector with empty values imputed based on the selected
`method`

.

Johannes Rainer

```
#######
## Impute missing values by linearly interpolating from neighboring
## non-empty elements
x <- c(3, NA, 1, 2, NA, NA, 4, NA, NA, NA, 3, NA, NA, NA, NA, 2)
imputeLinInterpol(x, method = "lin")
## visualize the interpolation:
plot(x = 1:length(x), y = x)
points(x = 1:length(x), y = imputeLinInterpol(x, method = "lin"), type = "l", col = "grey")
## If the first or last elements are NA, interpolation is performed from 0
## to the first non-empty element.
x <- c(NA, 2, 1, 4, NA)
imputeLinInterpol(x, method = "lin")
## visualize the interpolation:
plot(x = 1:length(x), y = x)
points(x = 1:length(x), y = imputeLinInterpol(x, method = "lin"), type = "l", col = "grey")
## If noInterpolAtEnds is TRUE no interpolation is performed at both ends
imputeLinInterpol(x, method = "lin", noInterpolAtEnds = TRUE)
######
## method = "linbase"
## "linbase" performs imputation by interpolation for empty elements based on
## 'distance' adjacent non-empty elements, setting all remaining empty elements
## to the baseValue
x <- c(3, NA, 1, 2, NA, NA, 4, NA, NA, NA, 3, NA, NA, NA, NA, 2)
## Setting distance = 0 skips imputation by linear interpolation
imputeLinInterpol(x, method = "linbase", distance = 0)
## With distance = 1 for all empty elements next to a non-empty element the value
## is imputed by linear interpolation.
xInt <- imputeLinInterpol(x, method = "linbase", distance = 1L)
xInt
plot(x = 1:length(x), y = x, ylim = c(0, max(x, na.rm = TRUE)))
points(x = 1:length(x), y = xInt, type = "l", col = "grey")
## Setting distance = 2L would cause that for all empty elements for which the
## distance to the next non-empty element is <= 2 the value is imputed by
## linear interpolation:
xInt <- imputeLinInterpol(x, method = "linbase", distance = 2L)
xInt
plot(x = 1:length(x), y = x, ylim = c(0, max(x, na.rm = TRUE)))
points(x = 1:length(x), y = xInt, type = "l", col = "grey")
```

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.