QRM 11 - Laptop session
Introduction
The objectives of the session are
(a). To understand how to perform Basic Historical Simulation, for a Single Asset and
a Multiple Asset portfolio
(b). To understand how to bootsrap VaR and ES.
Basic Historical Simulation
Single Asset Portfolio
The process is very simple. Given the current portfolio value, and a set of historical
returns, the loss distribution is found by simple multiplication. Let’s use FTSE, which
is column 4 in the EuStockmarkets dataset, as the single asset.
d <- EuStockMarkets[,4]
ft <- diff(d)/lag(d, k=-1)
The second command calculates the simple returns, which are now stored in d. If the
current portfolio is 1000, the loss distribution is found simply by multiplication:
Pt <- 1000
loss <- -Pt*ft
Have a look at it with, eg, the summary() and the hist() functions.
For VaR we just identify the quantile of the loss distribution we are interested in. Eg
for 95%
v95 <- quantile(loss,0.95)
v95
and for ES we can use a trick from Session 2, for selecting elements of a vector
according to some condition. For ES the condition is that the losses exceed VaR, and
the ES is the mean of those losses
t.loss <- loss[loss>v95]
ES95 <- mean(t.loss)
ES95
The first command selects those losses which meet the condition that they are larger
than v95, and stores them in t.loss. Then we find the mean of those losses and store
the result in ES95.
Exercise: Suppose you are operating under a risk limit such that ES at 95% cannot
exceed 15. How much do you have to reduce your portfolio to come inside this limit?
Trial and error is fine.
Exercise: Write, implement and test a function which takes as input a vector of
asset returns, and the current portfolio value, and calculates the VaR. And also one
that does the same for ES.
Two Asset Portfolio
There is a tricky feature we need to negotiate to get this to work. If you want to skip
the details that is fine, you can move on to the section titled “Calculations for Two
Asset portfolio”, and pick up there.
If you are still here, consider the multiplication that we need to do in the two asset
case. To keep things simple, suppose we have three days of historical returns, on
the two assets, and they all take the value 1. Also suppose the weights are 0.75 and
0.25 respectively, and the portfolio value is 10. So the data is
Rt =
1 11 1
1 1
 and  = •0.750.25˜
so we need to multiply each row of Rt by
−P ×  = −7.5 −2.5
and we would hope to get
−P ×  × Rt =
−7.5 −2.5−7.5 −2.5
−7.5 −2.5

But we don’t, as you can check below:
v <- c(1,1,1)
R <- cbind(v,v)
R
P <- 10
w <- c(0.75,0.25)
Pw <- -P*w
Pw
So all is set. But when we try the multiplication:
Pw * R
that is not what we want. Instead of doing the multiplication by rows, it does it by
column. But this is easily fixed. We just need to transpose the returns first, using the
t() function:
t(R)
Pw * t(R)
gives us just about the right answer, except the result is “on its side”. So we just use
t() again to flip it the right way up
t(Pw * t(R))
The loss is found from this by summing the values in each row. Here we can use the
rowSums() function, which does just that
loss <- rowSums(t(Pw * t(R)))
loss
Calculations for Two Asset Portfolio
Lets use data on the DAX and the FTSE from the EuStockMarkets data, which are in
columns 1 and 4.
d <- EuStockMarkets[,c(1,4)]
dax.ft <- diff(d)/lag(d, k = -1)
Now we’ve figured that out, we can look at the calculation flow to get the loss distri-
bution, in the case that the current portfolio value is 1000 and the weights are 0.75
and 0.25 respectively:
P <- 1000
w <- c(0.75,0.25)
Pw <- -P*w
loss <- rowSums(t(Pw * t(dax.ft)))
And as before
v95 <- quantile(loss,0.95)
v95
and for ES
t.loss <- loss[loss>v95]
ES95 <- mean(t.loss)
ES95
Exercise: how is portfolio risk affected by a move to an equally-weighted portfolio
in this case? Does risk increase or fall?
Bootstrapping
To recall two key ideas
ˆ Historical simulation is based on a fixed sample, hence there is no evident sam-
pling variation to allow is to perform inference.
ˆ A way round this is to resample from the data, with replacement, and so gener-
ate sampling variation this way. This process is known as bootstrapping.
The purpose of this section is to attempt to give some insights into this process. Later
on we see how to obtain bootstrapped confidence intervals for risk measures.
First we set up a dataset to play with. Suppose our data is a sample of 10 numbers:
x <- 11:20
x
mean(x)
The mean statistic would be the analogy with one of the risk measures we calculate
via historical simulation. Given the data, that is the only possible value that statistic
could take.
Now a slight detour, but there is a purpose to it. Remember that vectors possess
indexes (or indices if you prefer). So at index 1 is the number 11, at index 2 is the
number 12 and so on. We have seen to use this feature to select specific elements
form a vector. Eg
x[1]
x[c(1,2,4)]
the first gives us a vector containing the element 11. The second gives us the vector
consisting of the first, second and fourth elements of x.
In R, we can use variables in place of values, as we have seen many times. In other
words, instead of
x[c(1,2,4)]
we could get the same result in two steps
idx <- c(1,2,4)
idx
x[idx]
The second line is not essential of course, but is there to convince you that, to all
intents and purposes, idx is the vector c(1,2,4). Hence it can be used to select
elements from x.
The point of all this is to figure a way of sampling randomly from our data, which is
stored in a vector. The next step then is to find a way of generating a random index
for out vector. Here is where the function sample() comes in.
Try repeating
sample(1:10)
a few times. Although we could use these vectors as indexes to select elements from
x, there is a problem. Can you see what it is?
A better way is to add the ’replace’ option to the sample function
sample(1:10,replace=TRUE)
Repeat this a few times and you can see that some elements appear twice or more,
and therefore some other elements do not appear at all, and so we will get different
combinations of the elements of x each time. Try going round the following group of
commands a few times, and try to get a feel for what is going on.
idx <- sample(1:10,replace=TRUE)
idx
x[idx]
mean(x[idx])
We use sample to generate the indexes, then use the indexes to pick out the data
from x. Because the indexes vary, so do the elements of x that we pick out, and so
we get variation in our statistic (the mean).
To make this workable, R provides a package called boot, which we can load in the
usual way
library(boot)
The main element to this package is the function called boot. This function needs us
to supply three things
ˆ the data
ˆ the name of a function which calculates from the data the statistic we are inter-
ested in (more below)
ˆ The number of times we want resampling to occur
This means that in practice we don’t have to mess about with the sample command.
But we do have to write a function for boot to use. The function must be explicit
about how the statistic is calculated given a particular index (as discussed above).
So for the example of the sample mean, we could write the function:
mean.boot <- function(data,index){
t <- mean(data[index])
return(t)
}
which says, for a particular index vector, use that vector to select a sample of ele-
ments of x, and then find the mean of those elements.
Let’s see if it works for our index (idx) and our data (x):
idx
mean.boot(x,idx)
Seems fine. Now to use boot. First we run boot on our data, using the mean.boot
function, and store the results in b.m. We are asking for 1000 resamples of x.
b.m <- boot(x,mean.boot,R=1000)
Useful information is provided by the following commands
b.m
plot(b.m)
boot.ci(b.m,type="basic")
str(b.m)
tm <- b.m$t
mean(tm)
hist(tm)
The first gives some basic information. The second shows us the histogram of the
sample means calculated at each resampling. It gives a good idea of the variation in
the sample mean. The next command shows how we can find a confidence interval
for the statistic. str() is sometimes useful as it allows us to look at the structure of
an R object - this is useful if we want to access the results of some calculations. We
can see that the bootstrapped means are stored in the feild named ’t’ so we copy
them to a variable, and then calulate the bootstrap estimate of the mean, as well as
plotting the histogram again.
Hopefully you will have understood the basic idea by now. Applying this to a Risk
Measurement setting, let us see how to bootstrap the VaR. First we need the loss
distribution (of course we can easily do this for the two asset case, but here we use
a single asset for brevity).
For the loss distribution (I will use the FTSE returns):
Pt <- 1000
loss <- -Pt*ft
Now we need a function to calculate VaR from the loss distribution, using the form
that boot requires us to use :
var95.boot <- function(data,index){
d <- data[index] # permute
t <- quantile(d, 0.95)
return(t)
}
and then use boot, with the loss distribution as the data:
b.v <- boot(loss,var95.boot,R=1000)
b.v
plot(b.v)
boot.ci(b.v,type="basic")
We can see that in this case VaR is fairly precisely estimated. Clearly, it is very useful
to have confidence intervals for risk measures. Historical Simulation together with
bootstrapping is by far the most straightforward way of obtaining them.
Exercises:
(a). Can you figure a way to bootstrap the ES95 statistic?
(b). Can you figure a way to bootstrap a statistic in the case of two assets?
Resources
The Quick-R page has material and references to the bootstrap: http://www.statmethods.
net/advstats/bootstrapping.html