Application of reinsurance treaties to claims portfolios. The package creates a class Claims whose objective is to store claims and premiums, on which different treaties can be applied. A statistical analysis can then be applied to measure the impact of reinsurance, producing a table or graphical output. This package can be used for estimating the impact of reinsurance on several portfolios or for pricing treaties through statistical analysis. Documentation for the implemented methods can be found in "Reinsurance: Actuarial and Statistical Aspects" by Hansjöerg Albrecher, Jan Beirlant, Jozef L. Teugels (2017, ISBN: 978-0-470-77268-3) and "REINSURANCE: A Basic Guide to Facultative and Treaty Reinsurance" by Munich Re (2010) < https://www.munichre.com/site/mram/get/documents_E96160999/mram/assetpool.mr_america/PDFs/3_Publications/reinsurance_basic_guide.pdf>.
Implementation of a framework for application of reinsurance treaties on claims datasets, along with statistical and graphical analysis for cost estimation. This package can be used for estimating the impact of reinsurance on several portfolios or for pricing treaties through statistical analysis.
reinsureR can be installed from github.
The package depends on the followings:
The package is available from its GitHub repository.
devtools::install_github("arnaudbu/reinsureR", dependencies = TRUE)
This document aims at providing new users with an overview of the functionality brought by the package. For this purpose, a simple example will be developped in order to review all the implemented functions.
The package mainly relies on the
Claims class, whose purpose is to represent the claims and premiums on which reinsurance will be applied. All computations are executed within objects of this class.
This package is implemented from the perspective of the ceding company. Thus, will be computed claims and premiums kept by the company, and not the amounts paid to the reinsurer or received from it.
For the purpose of illustrating the application of reinsurance treaties to a claim dataset, let us create such a dataset.
The objective is to create several claim events per year for a couple of years and two different portfolios.
# Claim table constructionset.seed(1) # For reproducibilityc <- expand.grid(year = unlist(sapply(2000:2017, function(x) rep(x, rpois(1,8)))),portfolio = c("ptf1", "ptf2"),simulId = 1:100)c$amount <- pmax(rnorm(nrow(c), 200000, 100000), 0)c[sample(1:nrow(c), 5), ]
Five randomly picked rows from the table thus created are:
year portfolio simulId amount2003 ptf1 49 317274.32014 ptf2 56 143056.12017 ptf2 99 250803.62000 ptf2 86 431303.82001 ptf1 69 250328.3
Three dimensions are used in order to group claims:
Note that the there may be several lines associated with a triplet (year, portfolio, simulId), corresponding to different events occuring within a year for a portfolio and a scenario.
A table containing the insurance premiums for each year and portfolio is also needed in order to construct an object of class
Claims. Note that stochastic aspects are not taken into account for premiums. Except for the column simulId, column names are the same as in the table containing the claims. A unique premium amount should be associated to each year and portfolio.
# Premium table constructionp <- aggregate(amount ~ year + portfolio + simulId, c, sum)p <- aggregate(amount ~ year + portfolio, p, mean)p$amount[p$portfolio == "ptf1"] <- mean(p$amount[p$portfolio == "ptf1"])p$amount[p$portfolio == "ptf2"] <- mean(p$amount[p$portfolio == "ptf2"])
For the purpose of the example, we construct the premium table by averaging the yearly claims over the portfolios, without taking into account fee issues.
An object of class
Claims is constructed by calling the function
claims on the two previously generated tables:
claims <- claims(c, p)
The slots of an object of this class are:
All those values can be retrieved from their dedicated getters:
cl <- get_claims(claims)pm <- get_premiums(claims)cm <- get_commissions(claims)rn <- get_reinstatements(claims)tt <- get_treaties(claims)
Three types of treaties are available within the package:
They can all be applied to an object of class
Claims with the function
claims <- apply_treaty(claims, treaty)
In the examples, treaties are priced such that no gain can be made from reinsurance, which can be verified after the application of each treaty by the code
mean(summy(claims)$rns_gain), explained later.
Reinsurance treaties are applied on the amounts considered after application of all previous treaties.
In this example, a quota share treaty will first be applied on the first portfolio, then an excess of loss treaty will be applied on the second, before applying a stop loss treaty on both portfolios.
Quota Share treaties are constructed from their constructor
treaty_qs <- qs(csn_clm = 0.8,com = 0,ptf = "ptf1")claims <- apply_treaty(claims, treaty_qs)
Quota Share treaties are constructed from their constructor
treaty_xl <- xl(ded = 200000,lim = 30000,aad = 0,aal = Inf,prm = rate_prm,rns = c(0,0),ptf = "ptf2")claims <- apply_treaty(claims, treaty_xl)
Stop Loss treaties are constructed from their constructor
pp <- aggregate(amount ~ year + simulId + portfolio, c, sum)pp$amount[pp$portfolio == "ptf1"] <- pp$amount[pp$portfolio == "ptf1"] * 0.2pp <- aggregate(amount ~ year + simulId, pp, sum)r$amount_treaty[r$portfolio == "ptf1"] <- 0r <- aggregate(amount_treaty ~ year + simulId, r, sum)t <- summy(claims)rate_prm = mean(pmin(pmax(pp$amount - r$amount_treaty - 3000000, 0), 500000)) / mean(t$amount_after_treaty_2.prm)treaty_sl <- sl(ded = 3000000,lim = 500000,prm = rate_prm,ptf = "all")claims <- apply_treaty(claims, treaty_sl)
A summary of the effect of reinsurance on all portfolios can be obtain via the
The function takes two arguments:
The column rns_gain computes the gain from reinsurance for the ceding company, taking into account the difference in claims and premiums, with commissions and reinstatements.
It is also possible to get a graphical representation of the reinsurance effect on all portfolios with the function
draw(x, value = "all", moment = "gain", output = "boxplot")
The plotting parameters are: