exp.tilt {boot} | R Documentation |

## Exponential Tilting

### Description

This function calculates exponentially tilted multinomial distributions such that the resampling distributions of the linear approximation to a statistic have the required means.

### Usage

```
exp.tilt(L, theta = NULL, t0 = 0, lambda = NULL,
strata = rep(1, length(L)))
```

### Arguments

`L` |
The empirical influence values for the statistic of interest based on the
observed data. The length of |

`theta` |
The value at which the tilted distribution is to be centred. This is not
required if |

`t0` |
The current value of the statistic. The default is that the statistic equals 0. |

`lambda` |
The Lagrange multiplier(s). For each value of |

`strata` |
A vector or factor of the same length as |

### Details

Exponential tilting involves finding a set of weights for a data set to
ensure that the bootstrap distribution of the linear approximation to a
statistic of interest has mean `theta`

. The weights chosen to achieve this
are given by `p[j]`

proportional to
`exp(lambda*L[j]/n)`

, where `n`

is the number of data points.
`lambda`

is then
chosen to make the mean of the bootstrap
distribution, of the linear approximation to the statistic of interest, equal
to the required value `theta`

. Thus `lambda`

is defined as the
solution of a nonlinear equation.
The equation is solved by minimizing the Euclidean distance between
the left and right hand sides of the equation using the function `nlmin`

.
If this minimum is not equal to zero then the method fails.

Typically exponential tilting is used to find suitable weights for importance
resampling. If a small tail probability or quantile of the distribution of
the statistic of interest is required then a more efficient simulation is to
centre the resampling distribution close to the point of interest and
then use the functions `imp.prob`

or `imp.quantile`

to estimate the required
quantity.

Another method of achieving a similar shifting of the distribution is through
the use of `smooth.f`

. The function `tilt.boot`

uses `exp.tilt`

or `smooth.f`

to find the weights for a tilted bootstrap.

### Value

A list with the following components :

`p` |
The tilted probabilities. There will be |

`lambda` |
The Lagrange multiplier used in the equation to determine the tilted
probabilities. |

`theta` |
The values of |

### References

Davison, A. C. and Hinkley, D. V. (1997)
*Bootstrap Methods and Their Application*. Cambridge University Press.

Efron, B. (1981) Nonparametric standard errors and confidence intervals
(with Discussion). *Canadian Journal of Statistics*, **9**, 139–172.

### See Also

`empinf`

, `imp.prob`

, `imp.quantile`

, `optim`

, `smooth.f`

, `tilt.boot`

### Examples

```
# Example 9.8 of Davison and Hinkley (1997) requires tilting the resampling
# distribution of the studentized statistic to be centred at the observed
# value of the test statistic 1.84. This can be achieved as follows.
grav1 <- gravity[as.numeric(gravity[,2]) >=7 , ]
grav.fun <- function(dat, w, orig) {
strata <- tapply(dat[, 2], as.numeric(dat[, 2]))
d <- dat[, 1]
ns <- tabulate(strata)
w <- w/tapply(w, strata, sum)[strata]
mns <- as.vector(tapply(d * w, strata, sum)) # drop names
mn2 <- tapply(d * d * w, strata, sum)
s2hat <- sum((mn2 - mns^2)/ns)
c(mns[2]-mns[1], s2hat, (mns[2]-mns[1]-orig)/sqrt(s2hat))
}
grav.z0 <- grav.fun(grav1, rep(1, 26), 0)
grav.L <- empinf(data = grav1, statistic = grav.fun, stype = "w",
strata = grav1[,2], index = 3, orig = grav.z0[1])
grav.tilt <- exp.tilt(grav.L, grav.z0[3], strata = grav1[,2])
boot(grav1, grav.fun, R = 499, stype = "w", weights = grav.tilt$p,
strata = grav1[,2], orig = grav.z0[1])
```

*boot*version 1.3-30 Index]