程序代写 ST227: Applications of R in Life Insurance – cscodehelp代写

ST227: Applications of R in Life Insurance
Functions in R
27/02/2021

Copyright By cscodehelp代写 加微信 cscodehelp

▶ These ST227 workshops explore R’s application in the context of Life Insurance. The students are assumed to be familiar with the following topics:
▶ Data Types (Numeric, Character and Logical)
▶ Data Structures (Vector, List and Data Frames)
▶ Basic Iterations (for loops and apply family of functions).
▶ If you are not familiar with the above listed topics, you are recommended to consult either:
▶ ST226 course material,
▶ LSE’s pre-sessional R course, ▶ Office hours!

Motivation
▶ Why programming?
▶ Data revolution: modern needs to tackle big, diverse and complex data sets. ▶ Reusable codes and miminising human errors.
▶ Very in demand and required in the job market.
▶ High-level language and simple syntax. Minimal communication with the underlying
▶ Functional Programming style focusing on complex operations and simple data structures.
▶ The de-facto official language of statistical analysis.
▶ Interface with Python, C,C++ and more.
▶ The actual official language of the IFoA.

be a successful R programmer?
Most R programmers (including myself) are not very good at programming. Reason: R “programmers” are mostly trained statisticians and amateur programmers.
If that sounds like you, it’s important to expect the challenges:
▶ It is application-driven.
▶ Difficult to maintain readability of codes.
▶ The perfect codes can eliminate human errors. However, writing code can be very
error-prone.
▶ You spend more time debugging than writing codes.
How to overcome these challenges?
▶ Study R codes in contexts.
▶ Modularising codes into functions (more later).
▶ Frequent testing.
▶ Again, frequent testing.
Ultimately, programming is mostly mental muscle memory. Practice often.
All LSE academics in the department of statistics are experienced R users. Chase after your instructors. Utilise your resources!

▶ R is a functional programming language:
▶ We focus on the many operations performed on data. (as opposed to object-oriented
languages).
▶ Almost all tasks in R are achieved by defining, composing and reusing functions.
▶ What exactly are functions?
▶ Mathematics definition: a rule that maps each input value in the domain to a
corresponding output in the co-domain. For example: f:R→R, x→x2.
▶ Programming definition: a set of instructions that can be executed whenever called for. Let’s see an example:
f <- function(x){ xˆ2 ▶ Anatomy of a function: ▶ A name so we can refer to it. (There are anonymous functions, but let’s not worry about it for now) ▶ An input argument or several arguments. ▶ The body of the function which contains instructions. ▶ When we call for this function, its body is executed: ▶ An example of a function with multiple input arguments: f(x = 3) f(2) g <- function(x,y){ xˆ2 + yˆ2 } g(x=1,y=2) -Major differences to mathematical functions: 1. A programming function can have no input at all. 2. It might modify the context around it. 3. The input might not uniquely determine the output. ▶ Example: g <- function(){ print("Hello World!") print("Are you enjoying ST227?") ▶ An example of non-unique output: ▶ Technically - if you know the seed and the random number algorithm - then the output is unique. But conceptually we can think about this as a random-output function. ▶ Modifying external context and non-unique outputs can be undesirable behaviours. Document instances of them and proceed with cautions. h <- function(){ rnorm(1,mean=0,sd=1) Modelling Lifetime ▶ Let us fix a few notations: ▶ Tx : remaining lifetime of an individual aged x (an R+ valued random variable). ▶ t px = P(Tx ≥ t ), i.e. the t-year survival probability of the life aged x . ▶ tqx = P(Tx < t) = 1 − tpx, i.e. the death within t years probability of a life aged x. ▶ fx(t) = − d tpx, i.e. the density of Tx. dt ▶ Assume the distribution of T0 is known, the force of mortality is defined by: μx = lim P(Tx ≤ε). - The reverse is also true. If we are given a function μ : R+ → R+, then we can recover tpx by: 􏰀􏰂x+t 􏰁 􏰀􏰂t 􏰁 tpx =exp − μsds =exp − μx+sds . Modelling Lifetime ▶ The remaining lifetime distribution for all ages are completely determined by the force of mortality. ▶ From a computational point of view, we have reduced from a two-argument function, i.e. t px : R+ × R+ → [0, 1] to a one-argument function, i.e.: μ:R+ →R+. ▶ Constructing a mortality function from scratch is beyond the scope of this course. we will examine a few commonly used forms. Modelling Lifetime ▶ Let us consider the simplest case, constant mortality. Suppose μt ≡ 0.05. Calculate the probability that individuals aged 20, 40 and 80 will survive the next 20 years. ▶ Direct calculations are possible. ▶ We will use the “complicated” method to achieve a general template for this type of problems. mu <- function(t){ rep(0.05,times=length(t)) tpx <- function(t,x){ exp (-integrate(mu,lower =x,upper =t+x)$value) tpx(t=20 ,x =20) tpx(t=20 ,x =40) tpx(t=20 ,x =80) ▶ We duplicate the output of μ for vectorisation purpose. We’ll revisit this shortly. ▶ We see that it doesn’t matter what the current age is, this person has the same chance of surviving the next 20 years. This is called the memoryless property. Is this a good way to model human lifetime? Modelling Lifetime | Example: Makeham’s mortality ▶ A class of commonly considered mortality is called Gompertz-Makeham’s (or simply Makeham’s) mortality, which has the form: ▶ Exercise: using Makeham’s mortality with A = 5 × 10−4 , B = 7.5858 × 10−5 and c = 1.09144, calculate the probability that individuals aged 20,40 and 80 will survive the next 20 years. A = 5e-04; B=7.5858e-05; c = 1.09144 mu <- function(t){ tpx <- function(t,x){ exp(-integrate(mu,lower=x,upper=t+x)$value) tpx(t=20,x=20) tpx(t=20,x=40) tpx(t=20,x=80) A quick note on vectorisation ▶ In programming - one often needs to apply a function f : R → R to a vector x = (x1,..,xn) on an element-by-element basis, i.e. f (x) = (f (x1), f (x2), ..., f (xn)). ▶ This is called vectorisation. Many base functions in R have been vectorised by design. For instance: ▶ The integrate routine requires a vectorised function (see ?integrate). ▶ The above defined function tpx has not been vectorised. If you try tpx(t=20:25,x=20), it will throw an error. ▶ We will need to vectorise it in t for later applications of integrate. Let us redefine it: tpx <- function(t,x){ sapply(t, function(t){ -integrate(mu,lower=x,upper=t+x)$value Curtate Lifetime ▶ The curtate lifetime of an individual is the integer part of their total lifetime. For instance, if a person dies at age 85 years and 6 months, than the curtate life time is 85. ▶ Denote by Kx the remaining curtate lifetime of an individual aged x. Then: Kx =⌊Tx⌋, where the mapping t → ⌊t⌋ is the floor function. ▶ Exercise: calculate the curtate lifetime of a 20-year old individual with Makeham’s mortality function. ▶ The expected curtate lifetime is: ⌊t⌋ × μ20+t × t p20dt. ▶ Let us define the integrand. The floor function is built into R, so we can use it E(K20) = E(⌊T20⌋) = integrand <- function(t){ floor(t)*mu(20+t)*tpx(t,20) integrate(integrand,lower=0,upper=100) ▶ Handling an integral over (0, ∞) is a bit tricky. We replace ∞ with 100 as an approximation. Curtate Lifetime ▶ It can be shown that: E(Kx) = 􏰃npx. n=1 ▶ Utilise this formula to calculate the expected curtate lifetime: probs <- sapply(1:100,function(n){tpx(n,20)}) sum(probs) Life tables ▶ Given an initial age x0 and maximum age ω, let lx0 be an arbitrary positive number (usually 100,000). For any 0 ≤ t ≤ ω − x0, define: lx0+t =lx0 ×tpx0. ▶ lx+0+t can be interpreted as the number of survival at time t out of an lx0 number of individuals aged x0 at time 0. ▶ Moreover, define: dx =lx ×qx =lx ×(1−px). ▶ A life table is typically expressed in the following format (for concreteness, assume x0 =10andω=100): ... ... 100 d100 Life Tables ▶ Given a mortality function μ and boudnary ages x0 and ω, we can construct a life table: x0 <- 10; omega <- 100 x <- x0:omega lx <- numeric(length(x)) lx[1] <- 1e05 #1e05 = 10ˆ5 for(i in 2: length(lx)){ print(x[i-1]) lx[i] = lx[i -1]* tpx(1,x[i -1]) ▶ We will also need the sequence of probabilities px and qx for x = 10, ..., 100. px <- sapply(x,function(n){tpx(t=1,x=n)}) qx <- 1 - px dx = lx*qx ▶ The last step is to assumble the data frame: lifeTable <- data.frame(x,lx,dx) 程序代写 CS代考 加微信: cscodehelp QQ: 2235208643 Email: kyit630461@163.com