Home Page > > Details

data AssignmentHelp With ,R Programming AssignmentDebug ,R AssignmentGhostwriter ,program Course AssignmentHelp With Ghostwriter Statistics,,|Help With SQL

R - Efficient Frontier and Optimal Risky Portfolio of Several Assets
1. Introduction
We are still following up on our Risk and Return demo, CAL and Correlation tutorials. Remember,
we had a three-stock portfolio composed of Mc Donalds (MCD), General Electric (GE) and Apple
(AAPL) with the following weights: 25%, 25%, 50%. We have added three more securities :
Microsoft (MSFT), Bank of America (BAC) and an ETF on gold (GLD). The weights are no longer
relevant.
This six-stock portfolio is going to be our risky asset. We have already defined our risk-free asset in
the Risk and Return demo: the average (i.e. mean) T-bill rate over the 2010-01-01 to 2020-04-28
period.
The weights that we have been using so far to build our risky portfolio were chosen randomly. We
will now see how to find the optimal weight of each security so that we can build the optimal risky
portfolio.
2. Opening your Script
If you did not save the script that you wrote for the Risk and Return demo, don’t worry, you can do
it again… or use mine (note that we actually do not need the first part on Netflix, I included it just in
case some of you would want to have it):
—————————————————
library(quantmod)
#It is good practice to write a line about the code you want to write
below. Here we are going to download stock prices of Netflix
getSymbols("NFLX")
#Let's see what the last few trading days look like
tail(NFLX)
#Generate summary statistics
summary(NFLX)
#Create a chart of NFLX price time series
chartSeries(NFLX)
#Get annual returns of NFLX
annualReturn(NFLX)
1
#Get monthly arithmetic returns of NFLX in %
annualReturn(NFLX)*100
#For ease of writing codes from now on, let's assign a name to the values
returned by annualReturn(NFLX)*100
NFLX_a_retruns <- annualReturn(NFLX)*100
#Get the variance and the standard deviation of the annual returns of
NFLX
var(NFLX_a_retruns)
sd(NFLX_a_retruns)
#Create a graph of the annual returns of NFLX
chartSeries(NFLX_a_retruns)
#Now let's move to daily returns
dailyReturn(NFLX)
#let's assign a name to the values returned by dailyReturn(NFLX)
NFLX_d_retruns <- dailyReturn(NFLX)
#Create a graph of the daily returns of NFLX using a different layout
plot(NFLX_d_retruns)
#Create a histogram of daily returns of NFLX to see their distribution
hist(NFLX_d_retruns)
#Get a better visual of the histogram by increasing the number of breaks
(bins) and reducing the limits of the x-axis
hist(NFLX_d_retruns, breaks=200, xlim=c(-0.2,0.2))
#Transform the y-axis in Density (not frequency)
hist(NFLX_d_retruns, freq=FALSE, breaks=200, xlim=c(-0.2,0.2))
#Add a normal distribution curve with same mean and SD as NFLX daily
returns
curve(dnorm(x, mean=mean(NFLX_d_retruns), sd=sd(NFLX_d_retruns)),
add=TRUE)
#Kurtosis and Skewness values
install.packages("moments")
library(moments)
kurtosis(NFLX_d_retruns)
skewness(NFLX_d_retruns)
#Create a list of ticker symbols to download
tickers=c("GE","MCD","AAPL")
2
#Download data from "2010-01-01" to "2020-04-28"
getSymbols(tickers, from = "2010-01-01", to = "2020-04-28")
#Get monthly returns
mr_MCD <- monthlyReturn(MCD)
mr_GE <- monthlyReturn(GE)
mr_AAPL <- monthlyReturn(AAPL)
#Merge the monthly returns into one object
merged_returns <- merge.xts(mr_MCD, mr_GE, mr_AAPL)
#Assess weight of each stock
w <- c(.25, .25, .50)
library(PerformanceAnalytics)
#Calculate portfolio returns and plot them
portfolio_monthly_returns <- Return.portfolio(merged_returns, weights =
w)
chartSeries(portfolio_monthly_returns)
#Calculate the growth of 1 dollar invested in this portfolio at the
beginning till now and plot it
dollar_growth <- Return.portfolio(merged_returns, weights = w,
wealth.index = TRUE)
plot(dollar_growth)
#Download 13-week T-bills rates from "2010-01-01" to "2020-04-28"
getSymbols("^IRX",from = "2010-01-01", to = "2020-04-28")
#Calculate average risk-free rate, using the "Close" column", removing
NAs and transforming it into a decimal value
riskfree <- mean(IRX$IRX.Close, na.rm = TRUE)/100
#Get Sharpe ratio with risk-free rate = riskfree
SharpeRatio(portfolio_monthly_returns, Rf = riskfree)
#Get Slope of CAL
slope <- CAPM.CML.slope(portfolio_monthly_returns, Rf = riskfree)
#Get Curve of CAL
curve(slope*x+riskfree*100, from=0, to=10, xlab="Standard Deviation",
ylab="Return")
#Calculate average portfolio return and standard deviation
exp_m_return <- mean(portfolio_monthly_returns)*100
sd_m_return <- StdDev(portfolio_monthly_returns)*100
3
#Add the risky portfolio's point on the CAL
points(sd_m_return, exp_m_return, col="red")
#Calculate expected return and SD of a 70% risky/30% risk-free portfolio
assuming SD of riskfree=0
exp_return70_30 <- 0.7*exp_m_return + 0.3*riskfree*100
sd70_30 <- 0.7*sd_m_return
#Add the 70/30 portfolio's point on the CAL
points(sd70_30, exp_return70_30, col="blue")
#THIS IS THE NON-MANDATORY PART: Calculate SD of riskfree so that we have
the coordinates of the 2nd point on the new CAL: risk-free asset
sd_riskfree <- StdDev(IRX$IRX.Close)
#Calculate slope of new CAL
new_slope <- (exp_m_return - riskfree*100)/(sd_m_return - sd_riskfree)
#New CAL equation: y = new_slope*x + b. We want to figure out b. Let's
use x and y from the risky asset
#so that exp_m_retrun = new_slope*sd_m_return + b or
# b = exp_m_return - new_slope*sd_m_return
b_intercept <- exp_m_return - new_slope*sd_m_return
#Get Curve of new CAL
curve(new_slope*x+b_intercept, from=0, to=10, xlab="Standard Deviation",
ylab="Return")
#Add the risky portfolio's point on the CAL
points(sd_m_return, exp_m_return, col="red")
#Calculate expected return and SD of a 70% risky/30% risk-free portfolio
with actual SD of riskfree
exp_return70_30 <- 0.7*exp_m_return + 0.3*riskfree*100
sd70_30 <- 0.7*sd_m_return + 0.3*sd_riskfree
#Add the 70/30 portfolio's point on the CAL
points(sd70_30, exp_return70_30, col=“blue")
#Calculate correlation coefficient between Monthly returns of AAPL and
MCD
cor(mr_AAPL, mr_MCD)
#Calculate correlation coefficient between Monthly returns of GE and MCD
cor(mr_GE, mr_MCD)
4
#Calculate correlation coefficient between Monthly returns of AAPL and GE
cor(mr_AAPL, mr_GE)
#Download Microsoft (MSFT) price data with the same time frame as the one
we used before
getSymbols("MSFT", from = "2010-01-01", to = "2020-04-28")
#Calculate monthly returns of MSFT
mr_MSFT <- monthlyReturn(MSFT)
#Calculate correlation coefficient between Monthly returns of AAPL and
MSFT
cor(mr_AAPL, mr_MSFT)
#Download Bank of America (BAC) price data with the same time frame as
the one we used before
getSymbols("BAC", from = "2010-01-01", to = "2020-04-28")
#Calculate monthly returns of MSFT
mr_BAC <- monthlyReturn(BAC)
#Download Gold ETF (GLD) price data with the same time frame as the one
we used before
getSymbols("GLD", from = "2010-01-01", to = "2020-04-28")
#Calculate monthly returns of MSFT
mr_GLD <- monthlyReturn(GLD)
#Install and load package corrplot to create correlation matrix
install.packages("corrplot")
library(corrplot)
#We want to create a unique dataset with all the monthly returns of each
of the stock in our portfolio.
#We are going to merge mr_AAPL, mr_GE, mr_MCD, mr_MSFT, and BAC. But
first we need to rename the column in each "mr_" object.
#otherwise, we will lose their name in the data set.
colnames(mr_AAPL) <- "AAPL"
colnames(mr_GE) <- "GE"
colnames(mr_MCD) <- "MCD"
colnames(mr_MSFT) <- "MSFT"
colnames(mr_BAC) <- "BAC"
colnames(mr_GLD) <- "GLD"
#Create our dataset
risky_portfolio <- Reduce(merge, list(mr_AAPL, mr_GE, mr_MCD, mr_MSFT,
mr_BAC, mr_GLD))
5
#Calculate correlation matrix
risky_portfolio.cor <- cor(risky_portfolio)
#Get correlogram of the stocks in our portfolio
corrplot(risky_portfolio.cor)
—————————————————
Highlight what you just wrote (or pasted) and click “run” or cmd + enter key on a mac or ctrl +
enter key on a PC.
3. Building the Efficient Frontier
It is rather difficult (and long) to build the efficient frontier because it requires for us to compute
several “random” portfolios (i.e. with random weights) and select only the best one for every level
of risk (i.e. select the one with the highest return for every level of standard deviation).
Fortunately, there is an R package that deals with that: “PortfolioAnalytics” (https://
www.rdocumentation.org/packages/PortfolioAnalytics).
Install it and load it. Depending on your version of R and RStudio, you may have to install the
following packages along with “PortfolioAnaytics”:
install.packages('foreach')
install.packages("Rglpk")
install.packages("ROI.plugin.quadprog")
install.packages(“ROI.plugin.glpk")
Here are the steps to build the efficient frontier:
a) Set the portfolio specification
First we have to let “PortfolioAnalytics” knows the specifications of our portfolio: which assets to
use, the constraints and the objectives of our portfolio.
We are going to use the “portfolio.spec”, “add.constraint” and “add.objective” functions from
“PortfolioAnalytics”.
#Set Portfolio Specification: Which assets?
port_spec <- portfolio.spec(asset = colnames(risky_portfolio))
6
We are going to store the portfolio specifications in an object named port_spec.
Question 1: Using port_spec <- add.constraint(…) and port_spec <- add.objective(…), add the
following specifications to our portfolio:
a) type of constraint: “long_only” (we want no short-selling),
b) type of objective #1: ‘risk’, defined by ‘var’ (we want to minimize the risk)
c) type of objective #2: ‘return’, defined by ‘mean’ (we want to maximize the return)
Use ?add.constraint and ?add.objective to get some information on those functions or see some
examples.
TO INCLUDE IN YOUR EXAM COPY: Copy and paste your code in a .doc file along withe the
output of print(port_spec).
b) Computing the Efficient Frontier
Now that “PortfolioAnalytics” knows the specifications of our portfolio, we can calculate the
efficient frontier:
#Compute efficient frontier
efficient.frontier <- create.EfficientFrontier(
R = risky_portfolio,
portfolio = port_spec,
type = "mean-var",
n.portfolios = 30)
Note that we are using 30 portfolios to plot on the efficient frontier because it is a number large
enough to get a precise frontier but yet small enough so that we can still identify the portfolios on
the frontier.
c) Plotting the Efficient Frontier
We can now create the graph of the efficient frontier and the CAL optimal using our risk-free asset
(we are going to assume 0 standard deviation for ou risk-free asset).
#Plot efficient frontier
chart.EfficientFrontier(efficient.frontier,
match.col="StdDev",
RAR.text="Sharpe Ratio",
rf = riskfree,
tangent.line = TRUE,
chart.assets=TRUE,
labels.assets=TRUE,
xlim=c(0,0.15),
ylim=c(-0.01,0.05))
7
I have used the xlim and ylim (i.e. scales of the axis) so that every single stock can be displayed).
Note that GE has a negative expected return while having one of the highest standard deviation
amongst our stock sample. Most likely, GE will not be part of the optimal portfolio (i.e. its weight
will be = 0).
8
d) Finding the Optimal Risky Portfolio
There exist different optimisers that will return slightly different weights for the optimal portfolio.
We are going to rely on the one embedded in the chart.EfficientFrontier function.
#Get weights of portfolios along the frontier
summary(efficient.frontier, digits = 4)
We can see the weight for each stock in the 30 portfolios along the efficient frontier as well as their
corresponding mean return and standard deviation. For instance, we learn that the last portfolio
(30th) is composed entirely of AAPL, which means that the single stock of AAPL lies right on the
efficient frontier.
Although chart.EfficientFrontier is capable of identifying the tangency portfolio (i.e. the optimal
risky portfolio), I haven’t found a quick way to extract its corresponding weights directly from this
function… So for the lack of a better method, we can “manually” identify the tangency portfolio by
noting its position along the frontier. Here, we see that it is in 9th position, starting from the tail of
the frontier. Remark that choosing 4 digits was a bit of an overkill. We don’t need that sort of
precision (2 would have been enough). So portfolio #22 seems to be a good approximation of the
optimal risky portfolio. It is composed of 49% AAPL, 20% MCD, and 31% MSFT and yields a
mean monthly return of 1.7% with a 4.9% standard deviation. Its Sharpe Ratio (as displayed on the
graph) is 0.224.
**************************************************
PortfolioAnalytics Efficient Frontier
**************************************************
Call:
create.EfficientFrontier(R = risky_portfolio, portfolio = port_spec,
type = "mean-var", n.portfolios = 30)
Efficient Frontier Points: 30
Weights along the efficient frontier:
AAPL GE MCD MSFT BAC GLD
1 0.0020 0.0870 0.3503 0.1209 0.0248 0.4150
2 0.0179 0.0726 0.3552 0.1280 0.0239 0.4023
3 0.0338 0.0582 0.3602 0.1352 0.0230 0.3895
4 0.0497 0.0439 0.3652 0.1424 0.0220 0.3768
5 0.0656 0.0295 0.3702 0.1495 0.0211 0.3641
6 0.0815 0.0151 0.3752 0.1567 0.0202 0.3513
7 0.0974 0.0007 0.3801 0.1638 0.0193 0.3386
9
8 0.1195 0.0000 0.3799 0.1761 0.0091 0.3153
9 0.1422 0.0000 0.3792 0.1879 0.0000 0.2908
10 0.1668 0.0000 0.3768 0.1947 0.0000 0.2617
11 0.1914 0.0000 0.3743 0.2015 0.0000 0.2327
12 0.2161 0.0000 0.3719 0.2083 0.0000 0.2037
13 0.2407 0.0000 0.3695 0.2151 0.0000 0.1747
14 0.2653 0.0000 0.3671 0.2220 0.0000 0.1457
15 0.2899 0.0000 0.3646 0.2288 0.0000 0.1166
16 0.3146 0.0000 0.3622 0.2356 0.0000 0.0876
17 0.3392 0.0000 0.3598 0.2424 0.0000 0.0586
18 0.3638 0.0000 0.3574 0.2493 0.0000 0.0296
19 0.3884 0.0000 0.3550 0.2561 0.0000 0.0005
20 0.4211 0.0000 0.3054 0.2736 0.0000 0.0000
21 0.4538 0.0000 0.2549 0.2913 0.0000 0.0000
22 0.4866 0.0000 0.2044 0.3090 0.0000 0.0000
23 0.5194 0.0000 0.1539 0.3267 0.0000 0.0000
24 0.5522 0.0000 0.1034 0.3444 0.0000 0.0000
25 0.5850 0.0000 0.0529 0.3621 0.0000 0.0000
26 0.6178 0.0000 0.0024 0.3798 0.0000 0.0000
27 0.7111 0.0000 0.0000 0.2889 0.0000 0.0000
28 0.8074 0.0000 0.0000 0.1926 0.0000 0.0000
29 0.9037 0.0000 0.0000 0.0963 0.0000 0.0000
30 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000
Risk and return metrics along the efficient frontier:
mean StdDev out
1 0.0070 0.0300 0.0009
2 0.0075 0.0300 0.0009
3 0.0080 0.0301 0.0009
4 0.0085 0.0303 0.0009
5 0.0090 0.0306 0.0009
6 0.0094 0.0309 0.0010
7 0.0099 0.0313 0.0010
8 0.0104 0.0318 0.0010
9 0.0109 0.0325 0.0011
10 0.0114 0.0333 0.0011
11 0.0118 0.0342 0.0012
12 0.0123 0.0352 0.0012
13 0.0128 0.0364 0.0013
14 0.0133 0.0377 0.0014
15 0.0138 0.0391 0.0015
16 0.0142 0.0405 0.0016
17 0.0147 0.0421 0.0018
18 0.0152 0.0437 0.0019
19 0.0157 0.0454 0.0021
20 0.0162 0.0472 0.0022
21 0.0166 0.0491 0.0024
22 0.0171 0.0512 0.0026
10
23 0.0176 0.0534 0.0029
24 0.0181 0.0557 0.0031
25 0.0185 0.0581 0.0034
26 0.0190 0.0606 0.0037
27 0.0195 0.0635 0.0040
28 0.0200 0.0669 0.0045
29 0.0205 0.0709 0.0050
30 0.0209 0.0754 0.0057
3. Comparing our Optimal Risky Portfolio to a Benchmark
Now that we have found the optima risky portfolio we want to see how it has performed compared
to a given benchmark. Since our portfolio is composed of large US stocks, it makes sense to use the
S&P 500 index as a benchmark.
Question 2:
a) Download the index time series of the S&P 500 with the same time frame as the one used to
construct our optimal risky portfolio.
b) Calculate the monthly returns of the S&P 500 over the time period and assign them the name
“mr_SP500”
c) Calculate the growth of 1 dollar invested in our optimal risky portfolio at the beginning of our
time frame till the end of it and plot it (we used a similar approach in a previous tutorial).
d) Calculate the growth of 1 dollar invested in a S&P500 portfolio at the beginning of our time
frame till the end of it and plot it on the same plot as the one used in c) (the “line” function will help
you).
TO INCLUDE IN YOUR EXAM COPY: Copy and paste your code in your .doc file along withe
the plot.
4. Using a Single-Factor Model
With the help of a powerful software/language like R (or Python, or Matlab), building efficient
frontiers and hence finding the optimal risky portfolio has become relatively easy. But the SingleFactor
Model can provide with a different way of getting to the optimal risky portfolio.
First, let’s plot the Security Characteristic Line of each individual stock. In the package
“PerformanceAnalytics” (we have used it before), there is a function for that:
11
library(PerformanceAnalytics)
#Plot the SCL of AAPL
chart.Regression(
mr_SP500,
mr_AAPL,
Rf = riskfree,
excess.returns = TRUE,fit = "linear",
reference.grid = TRUE,
main = "AAPL's SCL")
12
Question 3:
Do the same for MCD and MSFT
TO INCLUDE IN YOUR EXAM COPY: Copy and paste your code in your .doc file along withe
the 2 plots.
Then, we can retrieve the betas, alphas, and epsilons of the stocks within the risky_portfolio by:
#Get betas, alphas, and epsilons
betas <- CAPM.beta(risky_portfolio, mr_SP500, Rf = riskfree)
alphas <- CAPM.alpha(risky_portfolio, mr_SP500, Rf = riskfree)
epsilons <- CAPM.epsilon(risky_portfolio, mr_SP500, Rf = riskfree)
NOT MANDATORY: Please find below the rest of the methodology to get to the optimal risky
portfolio weights. Note that the model is far from perfect.
#Calculate variance of mr_SP500
var_SP500 <- var(mr_SP500)
#Calculate optimal weights
w_GE <- alphas[,"GE"] / (var(mr_GE) - var_SP500)
w_MCD <- alphas[,"MCD"] / (var(mr_MCD) - var_SP500)
w_MSFT <- alphas[,"MSFT"] / (var(mr_MSFT) - var_SP500)
w_BAC <- alphas[,"BAC"] / (var(mr_BAC) - var_SP500)
w_GLD <- alphas[,"GLD"] / (var(mr_GLD) - var_SP500)
#Scale initial weights to 1 (only positive ones because of longonly
constraint)
weight_AAPL <- w_AAPL / (w_AAPL + w_MCD + w_MSFT)
weight_MCD <- w_MCD / (w_AAPL + w_MCD + w_MSFT)
weight_MSFT <- w_MSFT / (w_AAPL + w_MCD + w_MSFT)
———————————————————-

Contact Us - Email:99515681@qq.com    WeChat:codinghelp2
© 2014 www.asgnhelp.com
Programming Assignment Help!