VaR_NickLyn.Rmd

---
title: "Value-at-risk using GARCH models"
output:
  html_document:
    toc: yes
    toc_float:
      collapsed: no
      smooth_scroll: yes
  word_document:
    toc: yes
  pdf_document:
    toc: yes
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

# Loading the Packages used for the Analysis

```{r, message=FALSE, warning=FALSE}
library(dplyr)
library(quantmod)
library(tidyverse)
library(ggthemes)
library(forecast)
library(tseries)
library(data.table)
library(tidyquant)
library(gridExtra)
library(rugarch)
library(kableExtra)
library(tidyr)
library(goftest)
library(vars)
library(knitr)
library(FinTS)
library(aTSA)
library(timeSeries)
library(fGarch)
library(fBasics)
library(caTools)
library(PerformanceAnalytics)
library(zoo)
library(timetk)
library(sjPlot)
```

#Setting the working directory

```{r}
setwd("C:/Users/Admins/Desktop/R/Project_code/data")
```

#Data import

```{r, message=FALSE, warning=FALSE}
AEX<- read_csv("AEX.csv")
AEX['Date'] <- as.Date(AEX$Date)

CWEB <- read_csv("CWEB.csv")
CWEB['Date'] <- as.Date(CWEB$Date)

EWD <- read_csv("EWD.csv")
EWD['Date'] <- as.Date(EWD$Date)

FSZ <- read_csv("FSZ.csv")
FSZ['Date'] <- as.Date(FSZ$Date)

IXIC <- read_csv("IXIC.csv")
IXIC['Date'] <- as.Date(IXIC$Date)

VGK <- read_csv("VGK.csv")
VGK['Date'] <- as.Date(VGK$Date)
```


#selecting the 'close' and 'date' columns of each data set

```{r}
AEXprice<-AEX$Close
AEXdate<-AEX$Date
AEX.TS<- xts(AEXprice,order.by=AEXdate)

CWEBprice<-CWEB$Close
CWEBdate<-CWEB$Date
CWEB.TS<- xts(CWEBprice,order.by=CWEBdate)

EWDprice<-EWD$Close
EWDdate<-EWD$Date
EWD.TS<- xts(EWDprice,order.by=EWDdate)

FSZprice<-FSZ$Close
FSZdate<-FSZ$Date
FSZ.TS<- xts(FSZprice,order.by=FSZdate)


IXICprice<-IXIC$Close
IXICdate<-IXIC$Date
IXIC.TS<- xts(IXICprice,order.by=IXICdate)
VGKprice<-VGK$Close
VGKdate<-VGK$Date
VGK.TS<- xts(VGKprice,order.by=VGKdate)

```


#Plotting the average daily returns of each dataset

```{r}
p1<-ggplot(AEX.TS, aes(x=AEXdate,y=AEXprice))+geom_line()+
  theme(plot.title=element_text(hjust=0.5))+
  labs(x="Date",y="Price",title="Average Daily Price for AEX Stock Index")

p2<-ggplot(CWEB.TS, aes(x=CWEBdate,y=CWEBprice))+geom_line()+
  theme(plot.title=element_text(hjust=0.5))+
  labs(x="Date",y="Price",title="Average Daily Price for CWEB Stock Index")

p3<-ggplot(EWD.TS, aes(x=EWDdate,y=EWDprice))+geom_line()+
  theme(plot.title=element_text(hjust=0.5))+
  labs(x="Date",y="Price",title="Average Daily Price for CWEB Stock Index")


p4<-ggplot(VGK.TS, aes(x=VGKdate,y=VGKprice))+geom_line()+
  theme(plot.title=element_text(hjust=0.5))+
  labs(x="Date",y="Price",title="Average Daily Price for VGK Stock Index")

p5<-ggplot(IXIC.TS, aes(x=IXICdate,y=IXICprice))+geom_line()+
  theme(plot.title=element_text(hjust=0.5))+
  labs(x="Date",y="Price",title="Average Daily Price for IXIC Stock Index")

p6<-ggplot(FSZ.TS, aes(x=FSZdate,y=FSZprice))+geom_line()+
  theme(plot.title=element_text(hjust=0.5))+
  labs(x="Date",y="Price",title="Average Daily Price for FSZ Stock Index")

grid.arrange(p1 , p2 ,p3, p4, p5, p6)
```


#Calculate daily returns

```{r}
AEX.rtn <- returns(AEX.TS)
CWEB.rtn <- returns(CWEB.TS)
EWD.rtn <- returns(EWD.TS)
FSZ.rtn <- returns(FSZ.TS)
IXIC.rtn <- returns(IXIC.TS)
VGK.rtn <- returns(VGK.TS)
```


# calculating the log returns 

```{r}
logAEX.rtn<-diff(log(AEXprice), lag=1) 
logCWEB.rtn<-diff(log(CWEBprice), lag=1)
logEWD.rtn<-diff(log(EWDprice), lag=1)
logFSZ.rtn<-diff(log(FSZprice), lag=1)
logIXIC.rtn<-diff(log(IXICprice), lag=1)
logVGK.rtn<-diff(log(VGKprice), lag=1)
```

#Log returns data frame

```{r}
logs_dataframe <- data.frame(logAEX.rtn, logCWEB.rtn, logEWD.rtn,logFSZ.rtn,logIXIC.rtn ,logVGK.rtn)
basicStats(logs_dataframe)
table<- data.table(basicStats)
table
```

#t Tests

```{r}
t.test(AEX.rtn)
t.test(CWEB.rtn)
t.test(EWD.rtn)
t.test(FSZ.rtn)
t.test(IXIC.rtn)
t.test(VGK.rtn)
```

#JB Test

```{r}
jb1 <- jarqueberaTest(logCWEB.rtn);jb1
jb2 <- jarqueberaTest(logEWD.rtn);jb2
jb3 <- jarqueberaTest(logVGK.rtn);jb3
jb4 <- jarqueberaTest(logIXIC.rtn);jb4
jb5 <- jarqueberaTest(logAEX.rtn);jb5
jb6 <- jarqueberaTest(logFSZ.rtn);jb6

```

#ADF test

```{r}
adf.test(logCWEB.rtn)
adf.test(logEWD.rtn)
adf.test(logVGK.rtn)
adf.test(logIXIC.rtn)
adf.test(logAEX.rtn)
adf.test(logFSZ.rtn)
```

#Is the mean log return significantly different from zero=T test

```{r}
t.test(EWD.rtn)
```

#histogram

```{r}
h1 <- hist(logEWD.rtn, prob=TRUE, col = "grey")
lines(density(logEWD.rtn,adjust=8), col="blue", lwd=2)
```

#Is the mean log return significantly different from zero=T test

```{r}
t.test(VGK.rtn)
```


#histograms

```{r}
par(mfrow= c(1,2))
h1 <-hist(logCWEB.rtn, prob=TRUE, col = "grey")
lines(density(logCWEB.rtn,adjust=8), col="blue", lwd=2)
h2 <- hist(logEWD.rtn, prob=TRUE, col = "grey")
lines(density(logEWD.rtn,adjust=8), col="blue", lwd=2)
h3 <- hist(logVGK.rtn, prob=TRUE, col = "grey")
lines(density(logCWEB.rtn,adjust=8), col="blue", lwd=2)
h4 <- hist(logIXIC.rtn, prob=TRUE, col = "grey")
lines(density(logIXIC.rtn,adjust=8), col="blue", lwd=2)
h5 <- hist(logAEX.rtn, prob=TRUE, col = "grey")
lines(density(logAEX.rtn,adjust=8), col="blue", lwd=2)
h6 <- hist(logFSZ.rtn, prob=TRUE, col = "grey")
lines(density(logFSZ.rtn,adjust=8), col="blue", lwd=2)
```

#stationarity Test

```{r}
p1<-ggplot(CWEB.TS[-1], aes(CWEBdate[-1],logCWEB.rtn))+geom_line()+
  labs(x="Date",y="Log Return",title = "CWEB Log Returns plot")

p2<-ggplot(EWD.TS[-1], aes(EWDdate[-1],logEWD.rtn))+geom_line()+
  labs(x="Date",y="Log Return",title = "EWD Log Returns plot")


p3<-ggplot(VGK.TS[-1], aes(VGKdate[-1],logVGK.rtn))+geom_line()+
  labs(x="Date",y="Log Return",title = "VGK Log Returns plot")


p4<-ggplot(IXIC.TS[-1], aes(IXICdate[-1],logIXIC.rtn))+geom_line()+
  labs(x="Date",y="Log Return",title = "IXIC Log Returns plot")

p5<-ggplot(AEX.TS[-1], aes(AEXdate[-1],logAEX.rtn))+geom_line()+
  labs(x="Date",y="Log Return",title = "AEX Log Returns plot")

p6<-ggplot(FSZ.TS[-1], aes(FSZdate[-1],logFSZ.rtn))+geom_line()+
  labs(x="Date",y="Log Return",title = "FSZ Log Returns plot")

grid.arrange(p1,p2,p3,p4, p5,p6)
```



#serial correlation in the log return series

```{r}
Box.test(logCWEB.rtn,lag=20,type= "Ljung")
mod<-arima(logCWEB.rtn, order=c(0,0,0))
ArchTest(logCWEB.rtn, lag=20, demean = FALSE)

Box.test(logEWD.rtn,lag=20,type= "Ljung")
mod<-arima(logEWD.rtn, order=c(0,0,2))
ArchTest(logEWD.rtn, lag=20, demean = FALSE)

Box.test(logVGK.rtn,lag=20,type= "Ljung")
mod<-arima(logVGK.rtn, order=c(0,0,2))
ArchTest(logVGK.rtn, lag=20, demean = FALSE)

Box.test(logIXIC.rtn,lag=20,type= "Ljung")
mod<-arima(logIXIC.rtn, order=c(0,0,2))
ArchTest(logIXIC.rtn, lag=20, demean = FALSE)

Box.test(logAEX.rtn,lag=20,type= "Ljung")
mod<-arima(logAEX.rtn, order=c(0,0,2))
ArchTest(logAEX.rtn, lag=20, demean = FALSE)

Box.test(logFSZ.rtn,lag=20,type= "Ljung")
mod<-arima(logFSZ.rtn, order=c(0,0,1))
ArchTest(logFSZ.rtn, lag=20, demean = FALSE)

```


#Estimated Mean Equation

```{r}
AR1 <- Arima(logAEX.rtn,order=c(0,0,1))
AR1
AR2 <- Arima(logAEX.rtn,order=c(0,0,2))
AR2
AR3 <- Arima(logAEX.rtn,order=c(1,0,0))
AR3
AR4 <- Arima(logAEX.rtn,order=c(1,1,0))
AR4
AR5 <- Arima(logAEX.rtn,order=c(1,2,0))
AR5
AR6 <- Arima(logAEX.rtn,order=c(2,0,0))
AR6
AR7 <- Arima(logAEX.rtn,order=c(2,1,0))
AR7
AR8 <- Arima(logAEX.rtn,order=c(2,2,0))
AR8
```


#CWEB data

```{r}
AR1 <- Arima(logCWEB.rtn,order=c(0,0,1))
AR1
AR2 <- Arima(logCWEB.rtn,order=c(0,0,2))
AR2
AR3 <- Arima(logCWEB.rtn,order=c(1,0,0))
AR3
AR4 <- Arima(logCWEB.rtn,order=c(1,1,0))
AR4
AR5 <- Arima(logCWEB.rtn,order=c(1,2,0))
AR5
AR6 <- Arima(logCWEB.rtn,order=c(2,0,0))
AR6
AR7 <- Arima(logCWEB.rtn,order=c(2,1,0))
AR7
AR8 <- Arima(logCWEB.rtn,order=c(2,2,0))
AR8
```


#EWD data

```{r}
AR1 <- Arima(logEWD.rtn,order=c(0,0,1))
AR1
AR2 <- Arima(logEWD.rtn,order=c(0,0,2))
AR2
AR3 <- Arima(logEWD.rtn,order=c(1,0,0))
AR3
AR4 <- Arima(logEWD.rtn,order=c(1,1,0))
AR4
AR5 <- Arima(logEWD.rtn,order=c(1,2,0))
AR5
AR6 <- Arima(logEWD.rtn,order=c(2,0,0))
AR6
AR7 <- Arima(logEWD.rtn,order=c(2,1,0))
AR7
AR8 <- Arima(logEWD.rtn,order=c(2,2,0))
AR8
```


#FSZ

```{r}
AR1 <- Arima(logFSZ.rtn,order=c(0,0,1))
AR1
AR2 <- Arima(logFSZ.rtn,order=c(0,0,2))
AR2
AR3 <- Arima(logFSZ.rtn,order=c(1,0,0))
AR3
AR4 <- Arima(logFSZ.rtn,order=c(1,1,0))
AR4
AR5 <- Arima(logFSZ.rtn,order=c(1,2,0))
AR5
AR6 <- Arima(logFSZ.rtn,order=c(2,0,0))
AR6
AR7 <- Arima(logFSZ.rtn,order=c(2,1,0))
AR7
AR8 <- Arima(logFSZ.rtn,order=c(2,2,0))
AR8

```

#IXIC

```{r}
AR1 <- Arima(logIXIC.rtn,order=c(0,0,1))
AR1
AR2 <- Arima(logIXIC.rtn,order=c(0,0,2))
AR2
AR3 <- Arima(logIXIC.rtn,order=c(1,0,0))
AR3
AR4 <- Arima(logIXIC.rtn,order=c(1,1,0))
AR4
AR5 <- Arima(logIXIC.rtn,order=c(1,2,0))
AR5
AR6 <- Arima(logIXIC.rtn,order=c(2,0,0))
AR6
AR7 <- Arima(logIXIC.rtn,order=c(2,1,0))
AR7
AR8 <- Arima(logIXIC.rtn,order=c(2,2,0))
AR8
```


#VGK data

```{r}
AR1 <- Arima(logVGK.rtn,order=c(0,0,1))
AR1
AR2 <- Arima(logVGK.rtn,order=c(0,0,2))
AR2
AR3 <- Arima(logVGK.rtn,order=c(1,0,0))
AR3
AR4 <- Arima(logVGK.rtn,order=c(1,1,0))
AR4
AR5 <- Arima(logVGK.rtn,order=c(1,2,0))
AR5
AR6 <- Arima(logVGK.rtn,order=c(2,0,0))
AR6
AR7 <- Arima(logVGK.rtn,order=c(2,1,0))
AR7
AR8 <- Arima(logVGK.rtn,order=c(2,2,0))
AR8
```

# Auto arima

```{r}
auto.arima(logCWEB.rtn)
auto.arima(logEWD.rtn)
auto.arima(logVGK.rtn)
auto.arima(logIXIC.rtn)
auto.arima(logAEX.rtn)
auto.arima(logFSZ.rtn)
```

#Error  distribution AEX

```{r}
uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "std")
ugarchfit(data=logAEX.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logAEX.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "ged")
ugarchfit(data=logAEX.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sged")
ugarchfit(data=logAEX.rtn,spec=uc)


```

#error distribution CWEB 

```{r}
uc=ugarchspec(mean.model=list(armaOrder=c(1,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "std")
ugarchfit(data=logCWEB.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(1,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logCWEB.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(1,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "ged")
ugarchfit(data=logCWEB.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(1,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sged")
ugarchfit(data=logCWEB.rtn,spec=uc)

```


#error distribution EWD

```{r}
uc=ugarchspec(mean.model=list(armaOrder=c(2,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "std")
ugarchfit(data=logEWD.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(2,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logEWD.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(2,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "ged")
ugarchfit(data=logEWD.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(2,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sged")
ugarchfit(data=logEWD.rtn,spec=uc)
```


#Error distribution FSZ

```{r}
uc=ugarchspec(mean.model=list(armaOrder=c(1,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "std")
ugarchfit(data=logFSZ.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(1,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logFSZ.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(1,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "ged")
ugarchfit(data=logFSZ.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(1,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sged")
ugarchfit(data=logFSZ.rtn,spec=uc)

```

#error distribution IXIC 

```{r}
uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "std")
ugarchfit(data=logIXIC.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logIXIC.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "ged")
ugarchfit(data=logIXIC.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sged")
ugarchfit(data=logIXIC.rtn,spec=uc)
```



#error distribution VGK

```{r}
uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "std")
ugarchfit(data=logVGK.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logVGK.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "ged")
ugarchfit(data=logVGK.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sged")
ugarchfit(data=logVGK.rtn,spec=uc)

```


#Exponential GARCH AEX

```{r}
uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(model="eGARCH",garchOrder=c(1,1)),
              distribution.model = "sstd")

#CWEB

uc=ugarchspec(mean.model=list(armaOrder=c(1,0,0)),variance.model = list(model="eGARCH",garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logCWEB.rtn,spec=uc)

#EWD

uc=ugarchspec(mean.model=list(armaOrder=c(2,0,0)),variance.model = list(model="eGARCH",garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logEWD.rtn,spec=uc)

#FSZ
uc=ugarchspec(mean.model=list(armaOrder=c(1,0,0)),variance.model = list(model="eGARCH",garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logFSZ.rtn,spec=uc)

#IXIC

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(model="eGARCH",garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logIXIC.rtn,spec=uc)

#VGK

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(model="eGARCH",garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logVGK.rtn,spec=uc)

```


#parameter estimates for GARCH (1,1)

```{r}
uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logAEX.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(1,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logCWEB.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(2,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logEWD.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(1,0,0)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logFSZ.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logIXIC.rtn,spec=uc)

uc=ugarchspec(mean.model=list(armaOrder=c(0,0,2)),variance.model = list(garchOrder=c(1,1)),
              distribution.model = "sstd")
ugarchfit(data=logVGK.rtn,spec=uc)

```


#VaR and ES 500 window
#AEX GARCH with ES at 0.01 and 0.05 alpha

```{r}
specgarchaex = ugarchspec(variance.model = list(garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchaex, data = logAEX.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchaex,data=logAEX.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchaex;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logAEX.rtn[965:1381, drop = FALSE]);
actual = logAEX.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```


#AEX T GARCH 

```{r}
specgarchaex = ugarchspec(variance.model = list(model="fGARCH",submodel= "TGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchaex, data = logAEX.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchaex,data=logAEX.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchaex;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logAEX.rtn[965:1381, drop = FALSE]);
actual = logAEX.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```

#AEX Component standard 

```{r}
specgarchaex = ugarchspec(variance.model = list(model= "sGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchaex, data = logAEX.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchaex,data=logAEX.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchaex;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logAEX.rtn[965:1381, drop = FALSE]);
actual = logAEX.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```

#AEX I GARCH 

```{r,message=FALSE, warning=FALSE}
specgarchaex = ugarchspec(variance.model = list(model= "iGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchaex, data = logAEX.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchaex,data=logAEX.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchaex;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logAEX.rtn[965:1381, drop = FALSE]);
actual = logAEX.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#AEX P GARCH 

```{r}
specgarchaex = ugarchspec(variance.model = list(model="apARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchaex, data = logAEX.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchaex,data=logAEX.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchaex;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logAEX.rtn[965:1381, drop = FALSE]);
actual = logAEX.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#AEX E GARCH 

```{r}
specgarchaex = ugarchspec(variance.model = list(model="eGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchaex, data = logAEX.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchaex,data=logAEX.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchaex;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logAEX.rtn[965:1381, drop = FALSE]);
actual = logAEX.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```



#CWEB T GARCH 

```{r}
specgarchcweb = ugarchspec(variance.model = list(model="fGARCH",submodel= "TGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchcweb, data = logCWEB.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchcweb,data=logAEX.rtn[1:965,drop =
                                               FALSE])
Spec=specgarchcweb;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logCWEB.rtn[965:1381, drop = FALSE]);
actual = logCWEB.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```

#CWEB component standard GARCH 

```{r}
specgarchcweb = ugarchspec(variance.model = list(model="sGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchcweb, data = logCWEB.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchcweb,data=logAEX.rtn[1:965,drop =
                                               FALSE])
Spec=specgarchcweb;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logCWEB.rtn[965:1381, drop = FALSE]);
actual = logCWEB.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#CWEB I GARCH 

```{r,message=FALSE,warning=FALSE}
specgarchcweb = ugarchspec(variance.model = list(model="iGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchcweb, data = logCWEB.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchcweb,data=logAEX.rtn[1:965,drop =
                                               FALSE])
Spec=specgarchcweb;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logCWEB.rtn[965:1381, drop = FALSE]);
actual = logCWEB.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#CWEB P GARCH 

```{r}
specgarchcweb = ugarchspec(variance.model = list(model= "apARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchcweb, data = logCWEB.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchcweb,data=logAEX.rtn[1:965,drop =
                                               FALSE])
Spec=specgarchcweb;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logCWEB.rtn[965:1381, drop = FALSE]);
actual = logCWEB.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#CWEB E GARCH 

```{r}
specgarchcweb = ugarchspec(variance.model = list(model="eGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchcweb, data = logCWEB.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchcweb,data=logAEX.rtn[1:965,drop =
                                               FALSE])
Spec=specgarchcweb;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logCWEB.rtn[965:1381, drop = FALSE]);
actual = logCWEB.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#VaR and ES 500 window
#EWD GARCH with ES at 0.01 and 0.05 alpha

```{r}
specgarchewd = ugarchspec(variance.model = list(garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchewd, data = logEWD.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchewd,data=logEWD.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchewd;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logEWD.rtn[965:1381, drop = FALSE]);
actual = logEWD.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```

#EWD T GARCH 

```{r}
specgarchewd = ugarchspec(variance.model = list(model="fGARCH",submodel= "TGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchewd, data = logEWD.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchewd,data=logEWD.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchewd;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logEWD.rtn[965:1381, drop = FALSE]);
actual = logEWD.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#EWD component standard GARCH 

```{r}
specgarchewd = ugarchspec(variance.model = list(model="sGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchewd, data = logEWD.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchewd,data=logEWD.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchewd;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logEWD.rtn[965:1381, drop = FALSE]);
actual = logEWD.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#EWD I GARCH

```{r,message=FALSE,warning=FALSE}
specgarchewd = ugarchspec(variance.model = list(model="iGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchewd, data = logEWD.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchewd,data=logEWD.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchewd;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logEWD.rtn[965:1381, drop = FALSE]);
actual = logEWD.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#EWD P GARCH 

```{r}
specgarchewd = ugarchspec(variance.model = list(model= "apARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchewd, data = logEWD.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchewd,data=logEWD.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchewd;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logEWD.rtn[965:1381, drop = FALSE]);
actual = logEWD.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```


#EWD E GARCH

```{r}
specgarchewd = ugarchspec(variance.model = list(model="eGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchewd, data = logEWD.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchewd,data=logEWD.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchewd;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logEWD.rtn[965:1381, drop = FALSE]);
actual = logEWD.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#VaR and ES 500 window
#FSZ GARCH with ES at 0.01  and 0.05 alpha

```{r}
specgarchfsz = ugarchspec(variance.model = list(garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchfsz, data = logFSZ.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchfsz,data=logFSZ.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchfsz;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logFSZ.rtn[965:1381, drop = FALSE]);
actual = logFSZ.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#FSZ T GARCH 

```{r}
specgarchfsz = ugarchspec(variance.model = list(model="fGARCH",submodel= "TGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchfsz, data = logFSZ.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchfsz,data=logFSZ.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchfsz;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logFSZ.rtn[965:1381, drop = FALSE]);
actual = logFSZ.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#FSZ component standard GARCH

```{r}
specgarchfsz = ugarchspec(variance.model = list(model="sGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchfsz, data = logFSZ.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchfsz,data=logFSZ.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchfsz;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logFSZ.rtn[965:1381, drop = FALSE]);
actual = logFSZ.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#FSZ I GARCH 

```{r,message=FALSE, warning=FALSE}
specgarchfsz = ugarchspec(variance.model = list(model="iGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchfsz, data = logFSZ.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchfsz,data=logFSZ.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchfsz;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logFSZ.rtn[965:1381, drop = FALSE]);
actual = logFSZ.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#FSZ P GARCH 

```{r}
specgarchfsz = ugarchspec(variance.model = list(model= "apARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchfsz, data = logFSZ.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchfsz,data=logFSZ.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchfsz;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logFSZ.rtn[965:1381, drop = FALSE]);
actual = logFSZ.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#FSZ E GARCH 

```{r}
specgarchfsz = ugarchspec(variance.model = list(model="eGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchfsz, data = logFSZ.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchfsz,data=logFSZ.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchfsz;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logFSZ.rtn[965:1381, drop = FALSE]);
actual = logFSZ.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```


#VaR and ES 500 window
#IXIC GARCH with ES at 0.01 and 0.05 alpha

```{r}
specgarchIXIC = ugarchspec(variance.model = list(garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchIXIC, data = logIXIC.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchIXIC,data=logIXIC.rtn[1:965,drop =
                                                FALSE])
Spec=specgarchIXIC;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logIXIC.rtn[965:1381, drop = FALSE]);
actual = logIXIC.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```

#IXIC T GARCH 

```{r}
specgarchixic = ugarchspec(variance.model = list(model="fGARCH",submodel= "TGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchixic, data = logIXIC.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchixic,data=logIXIC.rtn[1:965,drop =
                                                FALSE])
Spec=specgarchixic;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logIXIC.rtn[965:1381, drop = FALSE]);
actual = logIXIC.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```

#IXIC component standard GARCH 

```{r}
specgarchixic = ugarchspec(variance.model = list(model="sGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchixic, data = logIXIC.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchixic,data=logIXIC.rtn[1:965,drop =
                                                FALSE])
Spec=specgarchixic;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logIXIC.rtn[965:1381, drop = FALSE]);
actual = logIXIC.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#IXIC I GARCH 

```{r,message=FALSE,warning=FALSE}
specgarchixic = ugarchspec(variance.model = list(model="iGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchixic, data = logIXIC.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchixic,data=logIXIC.rtn[1:965,drop =
                                                FALSE])
Spec=specgarchixic;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logIXIC.rtn[965:1381, drop = FALSE]);
actual = logIXIC.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#IXIC E GARCH

```{r}
specgarchixic = ugarchspec(variance.model = list(model="eGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchixic, data = logIXIC.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)
fit= ugarchfit(specgarchixic,data=logIXIC.rtn[1:965,drop =
                                                FALSE])
Spec=specgarchixic;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logIXIC.rtn[965:1381, drop = FALSE]);
actual = logIXIC.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#VaR and ES 500 window
#VGK GARCH with ES at 0.01 and 0.05 alpha

```{r}
specgarchvgk= ugarchspec(variance.model = list(garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchvgk, data = logVGK.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchvgk,data=logVGK.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchvgk;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logVGK.rtn[965:1381, drop = FALSE]);
actual = logVGK.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```

#VGK T GARCH 

```{r}
specgarchvgk = ugarchspec(variance.model = list(model="fGARCH",submodel= "TGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchvgk, data = logVGK.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchvgk,data=logVGK.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchvgk;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logVGK.rtn[965:1381, drop = FALSE]);
actual = logVGK.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#VGK component standard GARCH

```{r}
specgarchvgk = ugarchspec(variance.model = list(model="sGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchvgk, data = logVGK.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchvgk,data=logVGK.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchvgk;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logVGK.rtn[965:1381, drop = FALSE]);
actual = logVGK.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```



#VGK I GARCH 

```{r,message=FALSE, warning=FALSE}
specgarchvgk = ugarchspec(variance.model = list(model="iGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchvgk, data = logVGK.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchvgk,data=logVGK.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchvgk;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logVGK.rtn[965:1381, drop = FALSE]);
actual = logVGK.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```


#VGK P GARCH 

```{r}
specgarchvgk = ugarchspec(variance.model = list(model= "apARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchvgk, data = logVGK.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchvgk,data=logVGK.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchvgk;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logVGK.rtn[965:1381, drop = FALSE]);
actual = logVGK.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))
```


#VGK E GARCH

```{r}
specgarchvgk = ugarchspec(variance.model = list(model="eGARCH",garchOrder=c(1,1)), distribution.model ="sstd",mean.model =list(armaOrder=c(0,0,2)) )
roll = ugarchroll(specgarchvgk, data = logVGK.rtn, n.ahead = 1, forecast.length = 500,refit.every = 25, refit.window = "rolling",
                  parallel = TRUE,parallel.control = list(pkg = "snowfall", cores = 10), solver = "solnp",
                  solver.control = list(tol = 1e-05, delta = 1e-06, trace = 0),calculate.VaR = TRUE, VaR.alpha = c(0.01, 0.025, 0.05))
report(roll, type = "VaR", VaR.alpha = 0.01, conf.level = 0.99)
report(roll,type="VaR",VaR.alpha=0.05,conf.level=0.95)

fit= ugarchfit(specgarchvgk,data=logVGK.rtn[1:965,drop =
                                              FALSE])
Spec=specgarchvgk;setfixed(Spec)<-as.list(coef(fit))
filt = ugarchfilter(Spec, logVGK.rtn[965:1381, drop = FALSE]);
actual = logVGK.rtn[965:1381]
VaR = fitted(filt) + sigma(filt)*qdist("sstd", p=0.05, mu=0,
                                       sigma=1,skew=coef(fit)["skew"], shape=coef(fit)["shape"])
f = function(x) qdist("sstd",p=x,mu=0,sigma=1,skew=
                        coef(fit)["skew"], shape=coef(fit)["shape"])
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.01) $value/0.01;print(ESTest(0.01, actual,ES, VaR, boot = T))
ES = fitted(filt) + sigma(filt)*integrate(f, 0, 0.05) $value/0.05;print(ESTest(0.05, actual,ES, VaR, boot = T))

```

#Filtered historical simulation code
```{r,message=FALSE,warning=FALSE}

library(fExtremes)
library(FRAPO)

# VaR and ES at 0.01
#AEX

ys = sort(logAEX.rtn)                           
op = length(logAEX.rtn)*0.01                              
VaR = -ys[op]*500          
print(VaR)

ES = -mean(ys[1:op])*500   
print(ES)


#CWEB

ys = sort(logCWEB.rtn)                           
op = length(logCWEB.rtn)*0.01                              
VaR = -ys[op]*500          
print(VaR)

ES = -mean(ys[1:op])*500   
print(ES)

#EWD

ys = sort(logEWD.rtn)                           
op = length(logEWD.rtn)*0.01                              
VaR = -ys[op]*500          
print(VaR)

ES = -mean(ys[1:op])*500   
print(ES)


#FSZ

ys = sort(logFSZ.rtn)                           
op = length(logFSZ.rtn)*0.01                              
VaR = -ys[op]*500          
print(VaR)

ES = -mean(ys[1:op])*500   
print(ES)

#IXIC

ys = sort(logIXIC.rtn)                           
op = length(logIXIC.rtn)*0.01                              
VaR = -ys[op]*500          
print(VaR)

ES = -mean(ys[1:op])*500   
print(ES)

#VGK

ys = sort(logVGK.rtn)                           
op = length(logVGK.rtn)*0.01                              
VaR = -ys[op]*500          
print(VaR)

ES = -mean(ys[1:op])*500   
print(ES)


# VaR and ES at 0.05
#AEX

ys = sort(logAEX.rtn)                           
op = length(logAEX.rtn)*0.05                             
VaR = -ys[op]*500          
print(VaR)

ES = -mean(ys[1:op])*500   
print(ES)


#CWEB

ys = sort(logCWEB.rtn)                           
op = length(logCWEB.rtn)*0.05                           
VaR = -ys[op]*500          
print(VaR)

ES = -mean(ys[1:op])*500   
print(ES)

#EWD

ys = sort(logEWD.rtn)                           
op = length(logEWD.rtn)*0.05                             
VaR = -ys[op]*500          
print(VaR)

ES = -mean(ys[1:op])*500   
print(ES)


#FSZ

ys = sort(logFSZ.rtn)                           
op = length(logFSZ.rtn)*0.05                              
VaR = -ys[op]*500          
print(VaR)

ES = -mean(ys[1:op])*500   
print(ES)

#IXIC

ys = sort(logIXIC.rtn)                           
op = length(logIXIC.rtn)*0.05                              
VaR = -ys[op]*500          
print(VaR)

ES = -mean(ys[1:op])*500  
print(ES)

#VGK

ys = sort(logVGK.rtn)                           
op = length(logVGK.rtn)*0.05                             
VaR = -ys[op]*500         
print(VaR)

ES = -mean(ys[1:op])*500 
print(ES)
```

#That's the end.....Adios
Regards:
        Nick and Lynette