SynthETIC (version 1.1.0)

claim_payment_size: Size of Partial Payments (Without Inflation)

Description

Simulates and returns the constant dollar amount of each partial payment (i.e.without inflation) for each of the claims occurring in each of the periods.

Usage

claim_payment_size(
  frequency_vector,
  claim_size_list,
  no_payments_list,
  rfun,
  paramfun,
  ...
)

Arguments

frequency_vector

a vector of claim frequencies for all the periods.

claim_size_list

list of claim sizes.

no_payments_list

list of number of partial payments.

rfun

optional alternative random sampling function; see Details for default.

paramfun

parameters for the random sampling function, as a function of claim_size; see Details.

...

other arguments/parameters to be passed onto paramfun.

Explanation

Why did we set up a payment pattern as above?

The payment pattern is set up to reflect the typical pattern of a claim from an Auto liability line of business, which usually consists of:

1. (possibly) some small payments such as police reports, medical consultations and reports;

2. some more substantial payments such as hospitalisation, specialist medical procedures, equipment (e.g. prosthetics);

3. a final settlement with the claimant (usually the second last payment);

4. a smaller final payment, usually covering legal costs.

Claims in a number of other lines of business exhibit a similar structure, albeit with possible differences in the types of payment made.

Details

Returns a compound list structure such that the \(j\)th component of the \(i\)th sub-list gives the payment pattern (as a vector) for the \(j\)th claim of occurrence period \(i\).

The default rfun is set up in three steps. First we sample the complement of the proportion of total claim size represented by the last two payments, from a Beta distribution with mean $$1 - min(0.95, 0.75 + 0.04log[claim_size/(0.10 * ref_claim)])$$ where ref_claim is a package-wise global variable that we ask the user to define at the top of their code using set_parameters. CoV is assumed constant at 20%.

Next we simulate the proportion of last_two_pmts paid in the second last payment (settlement of the claim) from a Beta distribution with mean = 0.90 and CoV = 3%.

Lastly we sample the remaining payment proportions from a Beta distribution with mean $$(1 - last_two_payments)/(no_pmt - 2)$$ and CoV = 10%, which is followed by a normalisation such that the proportions add up to 1.

In the cases where there are only 2 or 3 partial payments, proceed as if there were 4 or 5 payments respectively with last_two_payments = 0. The trivial case is when the claim is settled with a single payment, which must be of the same amount as the total claim size.

Alternative sampling distributions are supported through rfun (the random generation function) and paramfun (which returns the parameters of rfun as a function of claim_size). The paramfun should return the distribution parameters in a vector, e.g. for gamma distribution paramfun should return a value in the format of c(shape = , scale = ). If a rfun is specified without a paramfun, SynthETIC will try to proceed without parameterisation (i.e. directly calling rfun with claim_size), and if it fails, then return an error message.

Examples

# set up
n_vector <- claim_frequency(I = 10)
claim_sizes <- claim_size(n_vector)
no_payments <- claim_payment_no(n_vector, claim_sizes)

# with default rfun
payments <- claim_payment_size(n_vector, claim_sizes, no_payments)
# partial payment sizes for claim 1 of occurrence period 1
payments[[1]][[1]]

# with some custom rfun
# simplistic case: (stochastically) equal amounts
my_func <- function(n, claim_size) {
  prop <- runif(n)
  prop <- prop / sum(prop)
  claim_size * prop
}
mypayments <- claim_payment_size(n_vector, claim_sizes, no_payments, my_func)
# partial payment sizes for claim 1 of occurrence period 1
mypayments[[1]][[1]]