View
29
Download
1
Category
Preview:
DESCRIPTION
optimization
Citation preview
Financial Optimization using MATLAB’s Financial Toolbox
Sonal Varshney, Arnab Sarkar
Advantages of using Financial Toolbox
The Financial toolbox includes a set of portfolio construction and optimization
functions designed to build an optimal portfolio that optimize risk adjusted return.
MATLAB uses matrices for calculations. Storing of data is done in matrices and
so it becomes easy and efficient to work in MATLAB.
Writing MATLAB programs are easy and very much similar to C.
There is a C++ compiler built in which can run already existing applications and
programs in MATLAB.
MATLAB enables user to import data from external files like spreadsheets. It is
possible to download data from Bloomberg also. The downloading of data can be
done in the form of matrices and then number crunching computation can be
performed on them.
It is possible to integrate CPLEX (a more efficient optimization package) to
integrate with MATLAB.
All these features enable a financial analyst and portfolio manager to work in MATLAB.
There are other in built functions in MATLAB for calculating yield of a bond, options
and other valuations models which can make overall life of a financial analyst simpler. A
financial analyst can perform a time-series analysis on a stock, he can check on the
pricing of options and other derivatives. These features provide a common working
platform for the financial analyst.
MATLAB provides lot of inbuilt functions for Portfolio Analysis and Optimization. A
Portfolio Managers faces a lot of constraints while constructing the portfolio, to meet the
objectives of the variety of investors. Regulations in the industry, different risk appetite
of the investors etc. result in constraints that mathematically take the form or linear
inequalities which can then be used to realize an optimal portfolio. Portfolio’s that
maximize the risk for a given risk, or minimize the risk for a given return are called
optimal portfolios.
SOME INFO ABOUT MATLAB
All of the toolbox functions are MATLAB M-files, made up of MATLAB statements that
implement specialized optimization algorithms. You can view the MATLAB code for
these functions using the statement
type function_name
and the whole code can is displayed in the command window.
If you need more information about a particular function type
help function_name
and all details about the function is displayed on the Command Window itself. MATLAB
help is pretty detailed and explanatory. You can go into the help section and do a search
to get detailed information about the command.
MATLAB interface:
A typical screenshot of the MATLAB window looks like this.
It is subdivided into three sub spaces.
Command Window – the window in which you work. It display the commands that are
typed and the output of those commands.
Command History – keeps a track of the history of the commands.
Present Working Directory or Workspace – Workspace gives the matrices that are
presently existing and the dimension of the matrices. The contents of these can be
viewed by double clicking on it.
Once can change the interface by going to the windows section and select which one is
required. If a function is preformed that makes a graph then another window with the
graph comes up.
It is possible to make M-files and then directly run them. There is an editor for making
and debugging the M-files. M-file editor can be opened by clicking “new” under the file
tab and then select M-file.
Portfolio Construction, Optimization and Analysing inbuilt Functions in MATLAB
Before getting into actual computation of portfolio optimization it will be good to have a
look at what inbuilt functions MATLAB has.
A word of caution: Make sure that the matrix and vectors that are fed as input to
the functions are of compatible sizes. (Mean that when you pass vectors to a function the
follow matrix algebra. – e.g Matrix A with dimension n*1 can be added to Matrix B with
the same dimension.)
Efficient Frontier Computation: Optimal portfolios define a line in the risk/return
plane called efficient frontier. Anything below it is not efficient and anything
above it is not possible with the given set of constraints.
(MGT 6078- Untitled - qcf-introclass-fall04.pdf (Pg-39)
https://banner.webct.gatech.edu/SCRIPT/83562200408/scripts/serve_home
frontcon:
It computes portfolio along the efficient frontier for a given group of
assets. Maximum and minimum bounds on the weights for each asset can
be specified by passing arguments when the function is called.
syntax:
[PortRisk, PortReturn, PortWts] = frontcon(ExpReturn,...
ExpCovariance, NumPorts, PortReturn, AssetBounds, Groups,
GroupBounds)
The input arguments are in the form of matrix on the Expected Return on
each asset, the variance-covariance matrix, number of portfolios one wants
to analyze along the efficient frontier. If a target expected return is
expected it can be specified in the PortReturn vector. If PortReturn is not
entered or [], NumPorts gives returns equally spaced between the
minimum and maximum values used.
The weight on individual assets can also be given as an input argument
specifying the maximum and minimum weights to be allocated to the
individual security. A portfolio Managers faces these kinds of constraints
day and night. e.g there are only specific securities which he can short
sell, or he might have a maximum bound on how much an individual
security can be as a part of the whole portfolio.
One also faces constraints on the portfolio based not only on the individual
security but also on a group of securities. e.g technology sector cannot be
more than 40% of the whole portfolio. or 20% of the portfolio consist of
bonds. Such kind of constraints can also be passed into frontcon.
Identification of the groups is passed in the form of a matrix and then
bounds on the group can be put. It will become easier once we see with an
example on how to input groups and group bonds.
If output argument are not specified (PortRisk, PortReturn, PortWts) then
frontcon outputs a graph of the efficient frontier.
Example to use frontcon to get the efficient frontier
e.g. as in the notes of Prof. Khorana - pg38.
Expected returns on assets A and B and the risk (Standard Deviation) associated
with them are given as
Ra = 0.12
Rb =0.16
SIGMAa = 0.1
SIGMAb = 0.2
Correlation coefficient: rho= 1
Covariance can be calculated as:
cov(x,y)=cov(y,x)=SIGMAa*SIGMAb*rho
A covariance matrix can be build using the above formula.
Matlab Code:
>> exp_return = [0.12 0.16];
>> exp_covariance = [0.01 0.02; 0.02 0.04];
>> frontcon(exp_return,exp_covariance);
Fig.1
When rho=0
>> exp_covariance = [0.01 0; 0 0.04];
>>frontcon(exp_return,exp_covariance);
The graph of the output is shown in Fig2.
When rho=-1
>> exp_covariance = [0.01 -.02;-.02 0.04];
>>frontcon(exp_return,exp_covariance);
The graph of the output is shown in Fig3.
Fig.2
Fig.3
Calling frontcon( ) without specifying any output arguments, a graph as shown in fig1 is
popped which represents the efficient frontier curve.
If the number of efficient portfolios generated along the efficient frontier is not specified
then it outputs 10 values as default. This will get clearer when output arguments are
specified.
Calling frontcon( ) while specifying the output arguments returns value of the
corresponding vectors. e.g in the pervious example with rho=1
>> [port_risk, port_return, port_wts] = frontcon(exp_return,exp_covariance)
gives the result as:
port_risk =
0.1000
0.1111
0.1222
0.1333
0.1444
0.1556
0.1667
0.1778
0.1889
0.2000
port_return =
0.1200
0.1244
0.1289
0.1333
0.1378
0.1422
0.1467
0.1511
0.1556
0.1600
port_wts =
1.0000 0
0.8889 0.1111
0.7778 0.2222
0.6667 0.3333
0.5556 0.4444
0.4444 0.5556
0.3333 0.6667
0.2222 0.7778
0.1111 0.8889
0 1.0000
Note: Each output argument portfolio risk, portfolio return and portfolio weights are
identified as corresponding rows in the vectors and matrix.
For portfolio 2 the vectors can be read as: To get an expected return of 13.54% the risk
that is computed along the efficient frontier is 0.2774 and the weights that have to be
assigned to securities A and B are 0.6154 and 0.3846 respectively.
If the number of efficient portfolios is specified say (numb_port) = 15
>> [port_risk, port_return, port_wts] = frontcon(exp_return,exp_covariance,num_port)
Then it outputs 15 row matrixes just as it showed for 10 portfolios.
Portfolio Optimization:
portopt:
portopt also construct portfolio’s on the efficient frontier. It is quite similar
frontcon but in portopt instead of specifying bunch of arguments like
group and group bounds it is easier to specify constraints in the form of a
matrix and input it into the optimization problem.
syntax:
[PortRisk, PortReturn, PortWts] = portopt(ExpReturn, ExpCovariance,
NumPorts, PortReturn, ConSet)
The difference between the input arguments of frontcon and portopt is that
of conset. conset is basically a matrix of constraints set. Constraints in a
portfolio optimization problem grow very fast. It may be possible that in
frontcon call the constraints cannot be specified.
ConSet can be specified by using portcons function (called portfolio
constraints-explained later) and there are some other ways to get around it.
It is generally in the form of Ax<=b form.
It however returns the same output arguments as the frontcon. If portopt is
invoked without output arguments it outputs a plot of efficient frontier
(similar to frontcon).
Allocation of assets in a Portfolio:
portalloc:
portalloc is an inbuilt function which returns optimal capital allocation to
the individual securities along the efficient frontier. The difference of
portalloc with frontcon / portopt is that portalloc divides the whole
portfolio into riskfree investment and risky investment depending upon the
risk appetite of the investor. And then it calculates weights to the different
securities in the portfolio along the efficient frontier. This can be thought
as a capital allocation decision between the risky and the non risky asset.
Where the capital allocation line intersects the efficient frontier lie the
asset allocation decision which assigns the weights to different securities
(Explained later with a figure).
It outputs data for the riskfree, riskless and the overall portfolio
characteristics.
syntax:
[RiskyRisk, RiskyReturn, RiskyWts, RiskyFraction, OverallRisk,
OverallReturn] = portalloc(PortRisk, PortReturn, PortWts,
RisklessRate, BorrowRate, RiskAversion)
portalloc takes input arguments as PortRisk, PortReturn, PortWts which
are outputs of the frontcon or portopt. The other input arguments are the
risk free rate, borrowing rate and the risk aversion of the investor. If
borrowing is not desirable option it is set to NaN [not-a-number]. If not
specified it is taken as default.
The output arguments are set of values associated with the optimal
portfolio. It gives the weights of individual securities, the expected return,
the risk of the portfolio, and how much to borrow.
Note: If borrowing is not done & RiskyFraction=1 then
RiskyRisk = OverallRisk &
RiskyReturn = OverallReturn &
If borrowing is done than RiskyFraction is more than 1.
e.g RiskyFraction = 1.5 implies that 50% of the money can be borrowed.
RiskyFraction = 0.8 implies that 80 of the capital allocation has been done
in the Risky part of the portfolio and 20% of capital allocation has been
done in the risk free securities at the risk free rate.
OverallRisk is the weighted average of the RiskyRisk and the Riskfree
allocation and so is the OverallReturn.
Risk free rate is specified in decimal (15% as 0.15)
Risk Aversion: It’s the coefficient of investor’s degree of risk aversion. It
basically establishes the increment in return that a particular investor will
require in order to make an increment in risk worthwhile. Typical values
of risk aversion coefficient range between 2.0 and 4.0, the higher value
representing lesser tolerance to risk.
Default: 3
The level of risk aversion is characterized by defining investor’s
indifference curve. The equation used to present risk aversion in the
Financial Toolbox is
U = E(r) – 0.005*A*sig^2
U: Utility Value E(r): Expected Return
sig:standard dev. A: index of investor’s aversion
A typical figure for portfolio optimization is shown below.
U (A) and U (B) are utility curves for investors A and B. We can see that
investor A is more risk averse than investor B. When we execute the portopt
then the point C gives the allocation of the capital into the risky and the risk
free assets for investor A and C’ for investor B. Beyond point P on the
capital allocation line the risky fraction will be greater than 1. (for more
details see Dr. Khorana Notes).
Specifying large constraints on the portfolio:
portcons:
portcons is an auxiliary function used to create the matrix of constraints.
One can specify all the data constraints at once, while specific portfolio
constraint functions only allow constraints to grow incrementally.
Computing the Risk and Return based on the weights of the assets.
portstats:
computes a portfolio’s risk and return
syntax:
[PortRisk, PortReturn] = portstats(ExpReturn, ExpCovariance,
PortWts)
Example using Portfolio Optimization function (portopt) by inputting some linear
constraints:
The auxiliary function portcons can be used to create the matrix of constraints with each
row representing an inequality in the form A*wts<=b, where A is a matrix and b is a
vector and wts is row vector of asset allocations.
A fund manager is bounded in his exposure to different markets around the world and is
given in the table.
Group Minimum Exposure Maximum Exposure
North America 0.3 0.75
Europe 0.10 0.55
Latin America 0.20 0.50
Asia 0.50 0.50
Table.1
Group Fund 1 Fund 2 Fund 3
North America X X
Europe X
Latin America X
Asia X X
Table.2
weights representing the exposure to each fund in a portfolio is
wts = [w1 w2 w3]
Using Table 1 and Table 2 we can formulate the following linear constraints:
1. w1 + w2 >= 0.30
2. w1 + w2 <=0.75
3. w3 >= 0.10
4. w3 <= 0.55
5. w1 >= 0.20
6. w1 <=.0.50
7. w2 + w3 =0.50
We have to input the following constraints in the form A*wts<=b;
The above constraints take the form
1. -w1 - w2 <= -0.30
2. w1 + w2 <= 0.75
3. -w3 <= -0.10
4. w3 <= 0.55
5. -w1 <= -0.20
6. w1 <= 0.50
7. -w2 - w3 <= -0.50
8. w2 + w3 <= 0.50
Converting them into matrix format we get:
A = [ -1 -1 0; 1 1 0; 0 0 -1; 0 0 1;-1 0 0; 1 0 0; 0 -1 -1;
0 1 1 ]
b = [ -0.30; 0.75;-0.10; 0.55;-0.20; 0.50;-0.50; 0.50 ]
Building the constraint matrix ConSet by concatenating the matrix A to the vector b.ConSet = [A,b];
When we run in MATLAB>> ExpReturn = [.1 .2 .15]>> ExpCovariance = [.005 -.010 .004;-0.01 .04 -.002; .004 -.002 .023]>> [PortRisk, PortReturn, PortWts] = portopt (ExpReturn, ExpCovariance,[],[],ConSet)
output:
port_risk =
0.0569
0.0569
0.0569
0.0570
0.0570
0.0571
0.0572
0.0573
0.0574
0.0586
port_return =
0.1169
0.1192
0.1215
0.1238
0.1261
0.1283
0.1306
0.1329
0.1352
0.1375
port_wts =
0.2950 0.2482 0.2518
0.3156 0.2528 0.2472
0.3361 0.2574 0.2426
0.3567 0.2620 0.2380
0.3773 0.2666 0.2334
0.3979 0.2712 0.2288
0.4185 0.2757 0.2243
0.4391 0.2803 0.2197
0.4597 0.2849 0.2151
0.5000 0.2500 0.2500
Note: The overall portfolio weights w1+w2+w3=1 was not a constraint.
If you add the constraint then we add two more constraints
w1+w2 + w3 <= 1 &
-w1-w2 - w3 <= -1 &
Doing the corresponding changes in A and b gives the following output
port_risk =
0.0586
port_return =
0.1375
port_wts =
0.5000 0.2500 0.2500
Recommended