CoCalc -- EfficientFrontier

GitHub Repository: braverock/portfolioanalytics
Path: blob/master/sandbox/riskbudgetpaper(superseded)/R_Allocation/EfficientFrontier_ComputeWeights.R
¹⁴³³ views
1
setwd("c:/Documents and Settings/Administrator/Desktop/risk budget programs")
2

3
cAssets = 4; p = priskbudget = 0.95;
4
mincriterion = "mES" ; percriskcontribcriterion = "mES";
5

6
# Load programs
7

8
source("R_Allocation/Risk_budget_functions.R"); 
9
library(zoo); library(fGarch); library("PerformanceAnalytics"); library("PortfolioAnalytics")
10
clean = TRUE
11

12
#   Load the data
13
firstyear = 1976 ; firstquarter = 1; lastyear = 2010; lastquarter = 2; 
14
data = read.table( file= paste("data/","/data.txt",sep="") ,header=T)
15
date = as.Date(data[,1],format="%Y-%m-%d")
16

17
monthlyR = zoo( data[,2:(1+cAssets)] , order.by = date )
18
if(clean){ monthlyR = clean.boudt2(monthlyR,alpha=0.05)[[1]] }
19

20
mu = apply(monthlyR,2,'mean')
21
sigma = cov(monthlyR)
22
M3 = PerformanceAnalytics:::M3.MM(monthlyR) 
23
M4 = PerformanceAnalytics:::M4.MM(monthlyR) 
24

25
#################################################################################
26
# Make Exhibit 3 Risk budget paper: Efficient frontier plot
27
#################################################################################
28

29
mESfun = function( series ){ return( operMES(  series , alpha = 0.05 , r = 2 ) ) }
30
assetmu = apply( monthlyR , 2 , 'mean' )
31
assetCVaR = apply( monthlyR , 2 , 'mESfun' )
32
minmu = min(assetmu); maxmu = max(assetmu); print(minmu*12); print(maxmu*12);
33

34
# Mean/CVaR concentration efficient portfolios
35
#-----------------------------------------------
36

37
# unconstrained solution is Minimum CVaR Concentration portfolio (having the equal risk contribution property):
38
# sol = MinMaxCompCVaRconportfolio(R=monthlyR, Riskupper = Inf ,Returnlower= -Inf )
39
minmu = min( apply(monthlyR,2,'mean' )); 
40
sol = PortfolioOptim(  minriskcriterion = "mES" , MinMaxComp = T, percriskcontribcriterion = "mES" , 
41
                Riskupper = Inf ,  mu = mu, sigma = sigma, M3=M3, M4=M4)
42

43
W               = as.vector( sol[[1]] ) ;   vmu             = as.vector( sol[[2]] )
44
vrisk           = as.vector( sol[[3]] ) ;   mPercrisk       = as.vector( sol[[4]] )  
45
vmaxpercrisk    = max( sol[[4]] )       ;   vmaxriskcontrib = max( sol[[5]] ) 
46

47
for( mutarget in seq(minmu+0.00001,maxmu,0.00001) ){
48
   sol = PortfolioOptim(  minriskcriterion = "mES" , MinMaxComp = T, percriskcontribcriterion = "mES" , 
49
                      Riskupper = Inf ,Returnlower= mutarget,
50
                      mu = mu, sigma = sigma, M3=M3, M4=M4) 
51
   W = rbind( W, as.vector( sol[[1]] ) )
52
   mPercrisk = rbind( mPercrisk , as.vector( sol[[4]] ) )
53
   vmu = c( vmu , as.vector( sol[[2]] ))
54
   vrisk = c( vrisk , as.vector( sol[[3]] ) )
55
   vmaxpercrisk = c( vmaxpercrisk , max( sol[[4]] ) )
56
   vmaxriskcontrib = c( vmaxriskcontrib , max( sol[[5]] ) )
57
}
58

59
# For the highest return targets, a very high penalty parameter is (sometimes) needed
60

61
for( mutarget in c(seq( max(vmu) , maxmu, 0.000001),maxmu) ){
62
   print( c("mutarget equal to",mutarget) )
63
   sol = PortfolioOptim(  minriskcriterion = "mES" , MinMaxComp = T, percriskcontribcriterion = "mES" , 
64
            Riskupper = Inf ,Returnlower= mutarget, penalty = 1e9,
65
            mu = mu, sigma = sigma, M3=M3, M4=M4) 
66
   W = rbind( W, as.vector( sol[[1]] ) )
67
   mPercrisk = rbind( mPercrisk , as.vector( sol[[4]] ) )
68
   vmu = c( vmu , as.vector( sol[[2]] ))
69
   vrisk = c( vrisk , as.vector( sol[[3]] ) )
70
   vmaxpercrisk = c( vmaxpercrisk , max( sol[[4]] ) )
71
   vmaxriskcontrib = c( vmaxriskcontrib , max( sol[[5]] ) )
72
}
73

74

75
if(clean){
76
 write.csv( W , file = "EffFrontierMinCVaRConc_weights_clean.csv" )
77
 write.csv( mPercrisk , file = "EffFrontierMinCVaRConc_percrisk_clean.csv" )
78
 EffFrontier_stats = cbind( vmu , vrisk , vmaxpercrisk , vmaxriskcontrib)
79
 write.csv( EffFrontier_stats , file = "EffFrontierMinCVaRConc_stats_clean.csv" )
80
}else{
81
 write.csv( W , file = "EffFrontierMinCVaRConc_weights.csv" )
82
 write.csv( mPercrisk , file = "EffFrontierMinCVaRConc_percrisk.csv" )
83
 EffFrontier_stats = cbind( vmu , vrisk , vmaxpercrisk , vmaxriskcontrib)
84
 write.csv( EffFrontier_stats , file = "EffFrontierMinCVaRConc_stats.csv" )
85
}
86

87

88

89
# Mean/CVaR efficient portfolios
90
#--------------------------------
91

92
# unconstrained solution is Minimum CVaR portfolio (having the property that percentage CVaR corresponds to porfolio weights):
93
minmu = min( apply(monthlyR,2,'mean' )); 
94
sol = PortfolioOptim(  minriskcriterion = "mES" , MinMaxComp = F, percriskcontribcriterion = "mES" , 
95
                Riskupper = Inf , mu = mu, sigma = sigma, M3=M3, M4=M4) 
96

97
W               = as.vector( sol[[1]] ) ;   vmu             = as.vector( sol[[2]] )
98
vrisk           = as.vector( sol[[3]] ) ;   mPercrisk       = as.vector( sol[[4]] )  
99
vmaxpercrisk    = max( sol[[4]] )       ;   vmaxriskcontrib = max( sol[[5]] ) 
100

101
for( mutarget in seq(minmu+0.00001,maxmu,0.00001) ){
102
   sol = PortfolioOptim(  minriskcriterion = "mES" , MinMaxComp = F, percriskcontribcriterion = "mES" , 
103
                      Riskupper = Inf ,Returnlower= mutarget,
104
                      mu = mu, sigma = sigma, M3=M3, M4=M4) 
105
   W = rbind( W, as.vector( sol[[1]] ) )
106
   mPercrisk = rbind( mPercrisk , as.vector( sol[[4]] ) )
107
   vmu = c( vmu , as.vector( sol[[2]] ))
108
   vrisk = c( vrisk , as.vector( sol[[3]] ) )
109
   vmaxpercrisk = c( vmaxpercrisk , max( sol[[4]] ) )
110
   vmaxriskcontrib = c( vmaxriskcontrib , max( sol[[5]] ) )
111
}
112

113
# For the highest return targets, a very high penalty parameter is (sometimes) needed
114

115
for( mutarget in c(seq( max(vmu) , maxmu, 0.000001),maxmu) ){
116
   print( c("mutarget equal to",mutarget) )
117
   sol = PortfolioOptim(  minriskcriterion = "mES" , MinMaxComp = F, percriskcontribcriterion = "mES" , 
118
            Riskupper = Inf ,Returnlower= mutarget, penalty = 1e9,
119
            mu = mu, sigma = sigma, M3=M3, M4=M4) 
120
   W = rbind( W, as.vector( sol[[1]] ) )
121
   mPercrisk = rbind( mPercrisk , as.vector( sol[[4]] ) )
122
   vmu = c( vmu , as.vector( sol[[2]] ))
123
   vrisk = c( vrisk , as.vector( sol[[3]] ) )
124
   vmaxpercrisk = c( vmaxpercrisk , max( sol[[4]] ) )
125
   vmaxriskcontrib = c( vmaxriskcontrib , max( sol[[5]] ) )
126
}
127

128
if(clean){
129
   write.csv( W , file = "EffFrontierMinCVaR_weights_clean.csv" )
130
   write.csv( mPercrisk , file = "EffFrontierMinCVaR_percrisk_clean.csv" )
131
   EffFrontier_stats = cbind( vmu , vrisk , vmaxpercrisk , vmaxriskcontrib)
132
   write.csv( EffFrontier_stats , file = "EffFrontierMinCVaR_stats_clean.csv" )
133
}else{
134
   write.csv( W , file = "EffFrontierMinCVaR_weights.csv" )
135
   write.csv( mPercrisk , file = "EffFrontierMinCVaR_percrisk.csv" )
136
   EffFrontier_stats = cbind( vmu , vrisk , vmaxpercrisk , vmaxriskcontrib)
137
   write.csv( EffFrontier_stats , file = "EffFrontierMinCVaR_stats.csv" )
138
}
139

140

141
# Mean/StdDev efficient portfolios (use quadprog)
142
#-------------------------------------------------
143

144
library(quadprog)
145
N = 4 ;  maxweight = 1; minweight = 0; sumweights = 1; 
146
Amat = rbind( rep(1,N) ,  diag(x =1,nrow=N,ncol=N) ,  diag(x =-1,nrow=N,ncol=N) , as.numeric(mu) );
147
bvec =  c( sumweights , rep(minweight,N), rep(-maxweight,N)  ) 
148
dvec = matrix( rep(0,N) , ncol=1 )
149

150
mutarget = -10000; 
151
# min(-d^T b + 1/2 b^T D b) with the constraints A^T b >= b_0.
152
optw = solve.QP( Dmat = sigma   , dvec = dvec , Amat = t(Amat) , 
153
   bvec = matrix( c(bvec,mutarget) , ncol = 1) , meq =1  )$solution
154
sol = ES(weights=optw, portfolio_method="component", mu = mu, sigma = sigma, m3=M3, m4=M4,invert=FALSE)
155
W               = optw                             ;   vmu             = sum(optw*mu)
156
vrisk           = sol$MES                          ;   mPercrisk       = as.vector( sol$pct_contrib_MES )  
157
vmaxpercrisk    = max( sol$pct_contrib_MES )       ;   vmaxriskcontrib = max( sol$contribution ) 
158

159
# unconstrained solution is Minimum CVaR portfolio (having the property that percentage CVaR corresponds to porfolio weights):
160
minmu = min( apply(monthlyR,2,'mean' )); 
161

162

163
for( mutarget in seq(minmu+0.00001,maxmu,0.00001) ){
164
   optw = solve.QP( Dmat = sigma   , dvec = dvec , Amat = t(Amat) , 
165
          bvec = matrix( c(bvec,mutarget) , ncol = 1) , meq =1  )$solution
166
   sol = ES(weights=optw, portfolio_method="component", mu = mu, sigma = sigma, m3=M3, m4=M4,invert=FALSE)
167
   W = rbind( W, optw )
168
   mPercrisk = rbind( mPercrisk , as.vector( sol$pct_contrib_MES ) )
169
   vmu = c( vmu , sum(optw*mu) )
170
   vrisk = c( vrisk , sol$MES )
171
   vmaxpercrisk = c( vmaxpercrisk , max( sol$pct_contrib_MES ) )
172
   vmaxriskcontrib = c( vmaxriskcontrib , max( sol$contribution ) )
173
}
174

175
if(clean){
176
   write.csv( W , file = "EffFrontierMinVar_weights_clean.csv" )
177
   write.csv( mPercrisk , file = "EffFrontierMinVar_percrisk_clean.csv" )
178
   EffFrontier_stats = cbind( vmu , vrisk , vmaxpercrisk , vmaxriskcontrib)
179
   write.csv( EffFrontier_stats , file = "EffFrontierMinVar_stats_clean.csv" )
180
}else{
181
   write.csv( W , file = "EffFrontierMinVar_weights.csv" )
182
   write.csv( mPercrisk , file = "EffFrontierMinVar_percrisk.csv" )
183
   EffFrontier_stats = cbind( vmu , vrisk , vmaxpercrisk , vmaxriskcontrib)
184
   write.csv( EffFrontier_stats , file = "EffFrontierMinVar_stats.csv" )
185
}
186

187

188

189

190
Product

Resources

Company
