ruinprob {bootruin} R Documentation

## The Probability of Ruin in the Classical Risk Process

### Description

This function calculates or estimates the probability of ruin in the classical (compund Poisson) risk process using several different methods.

### Usage

```ruinprob(x, param.list, compmethod = c("dg", "exp"),
flmethod = c("nonp", "exp", "lnorm", "custom"),
implementation = c("R", "C"), ...)
```

### Arguments

 `x` a numeric vector, matrix or array of individual claims. `param.list` a named list of parameters. It might contain any of the arguments except `x` and `...` `compmethod` a character string determining the algorithm for the computation. `flmethod` a character string indicating what cumulative probability distribution function is used for the increments of the running maximum of the aggregate loss process if `compmethod = "dg"`, see also Details and References. `reserve` a number indicating the initial surplus. `loading` a number determining the relative security loading. `fl` a function that is used as custom cumulative probability distribution to be used for the discretization if `flmethod = "custom"`. `interval` a number determining the approximation precision, viz. the mesh width of the discretization if `compmethod = "dg"`, see Details and References. `implementation` a character string determining whether to use the native implementation in R or the one in C. `...` further arguments are passed to `fl`.

### Details

The classical risk process, also called CramÃ©r-Lundberg risk process, is a stochastic model for an insurer's surplus over time and, for any t >= 0, it is given by

Y_t = r_0 + ct - Z_t,

where Z_t is a compund Poisson process, r_0 >= 0 is the initial surplus and c > 0 is the constant premium rate.

This function calculates, approximates or estimates (depending on what options are given) the probability of ruin in the infinite time horizon, i.e. the probability that Y_t ever falls below 0.

Currently there are two options for the `compmethod` argument. If `compmethod = "exp"`, the claims are assumed to be from an exponential distribution. In that case, the probability of ruin is given by

exp{-beta * r_0 / (mu (1 + beta))} / (1 + beta),

where mu is the mean claim size (estimated from `x`) and beta is the relative security loading.

For `compmethod = "dg"`, the recursive algorithm due to Dufresne and Gerber (1989) is used. In this case, the parameter `flmethod` determines what cumulative distribution function is used for the discretization. The possible choices are either a non-parametric estimator, parametric estimators for exponential or log-normal claims, or a user-supplied function (in which the argument `fl` must be specified). See the reference for more details on how this algorithm works.

### Value

The estimated or calculated probability of ruin. The shape and dimension of the output depends on the specifics of the claim data `x`. If `x` is a vector, the output is a single numeric value. In general, the dimension of the output is one less than that of `x`. More precisely, if `x` is an array, then the output value is an array of dimension `dim(x)[-1]`, see the note below.

### Note

If `x` is an array rather than a vector, the function acts as if it was called through `apply` with `MARGIN = 2:length(dim(x))`

If an option is given both explicitly and as part of the `param.list` argument, then the value given explicitly takes precedence. This way the parameter list, saved as a variable, can be reused, but modifications of one or more parameter values are still possible.

### References

Dufresne, F. and Gerber, H.-U. (1989) Three Methods to Calculate the Probability of Ruin. ASTIN Bulletin, 19(1), pp. 71–90.

`ruinprob.test`

### Examples

```# Claims have an exponential distribution with mean 10
x <- rexp(10, 0.1)
print(x)

# The estimated probability of ruin

# The true probability of ruin of the risk process
ruinprob(
flmethod = "exp", compmethod = "exp"
)
```

[Package bootruin version 1.2-4 Index]