bat365 Homepage

PortfolioCVaR

Creates PortfolioCVaR object for conditional value-at-risk portfolio optimization and analysis

Description

Use PortfolioCVaR to create a PortfolioCVaR object for conditional value-at-risk portfolio optimization.

The main workflow for CVaR portfolio optimization is to create an instance of a PortfolioCVaR object that completely specifies a portfolio optimization problem and to operate on the PortfolioCVaR object using supported functions to obtain and analyze efficient portfolios. For details on this workflow, see PortfolioCVaR Object Workflow.

You can use the PortfolioCVaR object in several ways. To set up a portfolio optimization problem in a PortfolioCVaR object, the simplest syntax is:

p = PortfolioCVaR;

This syntax creates a PortfolioCVaR object, p, such that all object properties are empty.

The PortfolioCVaR object also accepts collections of name-value pair arguments for properties and their values. The PortfolioCVaR function accepts inputs for properties with the general syntax:

	p = PortfolioCVaR('property1',value1,'property2',value2, ... );

If a PortfolioCVaR object already exists, the syntax permits the first (and only the first argument) of the PortfolioCVaR object to be an existing object with subsequent name-value pair arguments for properties to be added or modified. For example, given an existing PortfolioCVaR object in p, the general syntax is:

p = PortfolioCVaR(p,'property1',value1,'property2',value2, ... );

Input argument names are not case sensitive, but must be completely specified. In addition, several properties can be specified with alternative argument names (see Shortcuts for Property Names). The PortfolioCVaR object tries to detect problem dimensions from the inputs and, once set, subsequent inputs can undergo various scalar or matrix expansion operations that simplify the overall process to formulate a problem. In addition, a PortfolioCVaR object is a value object so that, given portfolio p, the following code creates two objects, p and q, that are distinct:

q = PortfolioCVaR(p, ...)

After creating a PortfolioCVaR object, you can use the associated object functions to set portfolio constraints, analyze the efficient frontier, and validate the portfolio model.

For more detailed information on the theoretical basis for conditional value-at-risk portfolio optimization, see Portfolio Optimization Theory.

Creation

Syntax

p = PortfolioCVaR

p = PortfolioCVaR(Name,Value)

p = PortfolioCVaR(p,Name,Value)

Description

example

p = PortfolioCVaR creates an empty PortfolioCVaR object for conditional value-at-risk portfolio optimization and analysis. You can then add elements to the PortfolioCVaR object using the supported "add" and "set" functions. For more information, see Creating the PortfolioCVaR Object.

example

p = PortfolioCVaR(Name,Value) creates a PortfolioCVaR object (p) and sets Properties using name-value pairs. For example, p = PortfolioCVaR('AssetList',Assets(1:12)). You can specify multiple name-value pairs.

example

p = PortfolioCVaR(p,Name,Value) creates a PortfolioCVaR object (p) using a previously created PortfolioCVaR object p and sets Properties using name-value pairs. You can specify multiple name-value pairs.

Input Arguments

expand all

`p` — Previously constructed PortfolioCVaR object
object

Previously constructed PortfolioCVaR object, specified using PortfolioCVaR.

Properties

expand all

Setting Up the PortflioCVaR Object

`AssetList` — Names or symbols of assets in universe
`[]` (default) | cell array of character vectors | string array

Names or symbols of assets in the universe, specified as a cell array of character vectors or a string array.

Data Types: cell | string

`InitPort` — Initial portfolio
`[]` (default) | vector

Initial portfolio, specified as a vector.

Data Types: double

`Name` — Name for instance of PortfolioCVaR object
`[]` (default) | character vector | string

Name for instance of the PortfolioCVaR object, specified as a character vector or string.

Data Types: char | string

`NumAssets` — Number of assets in the universe
`[]` (default) | integer scalar

Number of assets in the universe, specified as an integer scalar.

Data Types: double

PortfolioCVaR Object Constraints

`AEquality` — Linear equality constraint matrix
`[]` (default) | matrix

Linear equality constraint matrix, specified as a matrix. For more information, see Linear Equality Constraints.

Data Types: double

`AInequality` — Linear inequality constraint matrix
`[]` (default) | matrix

Linear inequality constraint matrix, specified as a matrix. For more information, see Linear Inequality Constraints.

Data Types: double

`bEquality` — Linear equality constraint vector
`[]` (default) | vector

Linear equality constraint vector, specified as a vector. For more information, see Linear Equality Constraints.

Data Types: double

`bInequality` — Linear inequality constraint
`[]` (default) | vector

Linear inequality constraint vector, specified as a vector. For more information, see Linear Inequality Constraints.

Data Types: double

`GroupA` — Group A weights to be bounded by weights in group B
`[]` (default) | matrix

Group A weights to be bounded by weights in group B, specified as a matrix. For more information, see Group Constraints.

Data Types: double

`GroupB` — Group B weights
`[]` (default) | matrix

Group B weights, specified as a matrix. For more information, see Group Constraints.

Data Types: double

`GroupMatrix` — Group membership matrix
`[]` (default) | matrix

Group membership matrix, specified as a matrix. For more information, see Group Ratio Constraints.

Data Types: double

`LowerBound` — Lower-bound constraint
`[]` (default) | vector

Lower-bound constraint, specified as a vector. For more information, see 'Simple' Bound Constraints and 'Conditional' Bound Constraints.

Data Types: double

`LowerBudget` — Lower-bound budget constraint
`[]` (default) | scalar

Lower-bound budget constraint, specified as a scalar. For more information, see Budget Constraints.

Data Types: double

`LowerGroup` — Lower-bound group constraint
`[]` (default) | vector

Lower-bound group constraint, specified as a vector. For more information, see Group Constraints.

Data Types: double

`LowerRatio` — Minimum ratio of allocations between Groups A and B
`[]` (default) | vector

Minimum ratio of allocations between GroupA and GroupB, specified as a vector. For more information, see Group Ratio Constraints.

Data Types: double

`UpperBound` — Upper-bound constraint
`[]` (default) | vector

Upper-bound constraint, specified as a vector. For more information, see 'Simple' Bound Constraints and 'Conditional' Bound Constraints.

Data Types: double

`UpperBudget` — Upper-bound budget constraint
`[]` (default) | scalar

Upper-bound budget constraint, specified as a scalar. For more information, see Budget Constraints.

Data Types: double

`UpperGroup` — Upper-bound group constraint
`[]` (default) | vector

Upper-bound group constraint, specified as a vector. For more information, see Group Constraints.

Data Types: double

`UpperRatio` — Maximum ratio of allocations between Groups A and B
`[]` (default) | vector

Maximum ratio of allocations between GroupA and GroupB, specified as a vector. For more information, see Group Ratio Constraints.

Data Types: double

`BoundType` — Type of bounds for each asset weight
`'Simple'` (default) | character vector with value `'Simple'` or `'Conditional'` | string with value `"Simple"` or `"Conditional"` | cell array of character vectors with values `'Simple'` or `'Conditional'` | string array with values `"Simple"` or `"Conditional"`

Type of bounds for each asset weight, specified as a scalar character vector or string, or a cell array of character vectors or a string array. For more information, see setBounds.

Data Types: char | cell | string

`MinNumAssets` — Minimum number of assets allocated in portfolio
`[]` (default) | numeric

Minimum number of assets allocated in portfolio, specified as a scalar numeric value. For more information, see setMinMaxNumAssets and Cardinality Constraints.

Data Types: double

`MaxNumAssets` — Maximum number of assets allocated in portfolio
`[]` (default) | numeric

Maximum number of assets allocated in portfolio, specified as a scalar numeric value. For more information, see setMinMaxNumAssets and Cardinality Constraints.

Data Types: double

`Turnover` — Turnover constraint
`[]` (default) | scalar

Turnover constraint, specified as a scalar. For more information, see Average Turnover Constraints and One-way Turnover Constraints.

Data Types: double

`SellTurnover` — Turnover constraint on sales
`[]` (default) | scalar

Turnover constraint on sales, specified as a scalar. For more information, see Average Turnover Constraints and One-way Turnover Constraints.

Data Types: double

`BuyTurnover` — Turnover constraint on purchases
`[]` (default) | scalar

Turnover constraint on purchases, specified as a scalar. For more information, see Average Turnover Constraints and One-way Turnover Constraints.

Data Types: double

PortfolioCVaR Object Modeling

`BuyCost` — Proportional purchase costs
`[]` (default) | vector

Proportional purchase costs, specified as a vector. For more information, see Net Portfolio Returns.

Data Types: double

`RiskFreeRate` — Risk-free rate
`[]` (default) | scalar

Risk-free rate, specified as a scalar.

Data Types: double

`ProbabilityLevel` — Value-at-risk probability level which is 1 − (loss probability)
`[]` (default) | scalar

Value-at-risk probability level which is 1 − (loss probability), specified as a scalar.

Data Types: double

`NumScenarios` — Number of scenarios
`[]` (default) | integer scalar

Number of scenarios, specified as an integer scalar.

Data Types: double

`SellCost` — Proportional sales costs
`[]` (default) | vector

Proportional sales costs, specified as a vector. For more information, see Net Portfolio Returns.

Data Types: double

Object Functions

`setAssetList`	Set up list of identifiers for assets
`setInitPort`	Set up initial or current portfolio
`setDefaultConstraints`	Set up portfolio constraints with nonnegative weights that sum to 1
`estimateAssetMoments`	Estimate mean and covariance of asset returns from data
`setCosts`	Set up proportional transaction costs for portfolio
`addEquality`	Add linear equality constraints for portfolio weights to existing constraints
`addGroupRatio`	Add group ratio constraints for portfolio weights to existing group ratio constraints
`addGroups`	Add group constraints for portfolio weights to existing group constraints
`addInequality`	Add linear inequality constraints for portfolio weights to existing constraints
`getBounds`	Obtain bounds for portfolio weights from portfolio object
`getBudget`	Obtain budget constraint bounds from portfolio object
`getCosts`	Obtain buy and sell transaction costs from portfolio object
`getEquality`	Obtain equality constraint arrays from portfolio object
`getGroupRatio`	Obtain group ratio constraint arrays from portfolio object
`getGroups`	Obtain group constraint arrays from portfolio object
`getInequality`	Obtain inequality constraint arrays from portfolio object
`getOneWayTurnover`	Obtain one-way turnover constraints from portfolio object
`setGroups`	Set up group constraints for portfolio weights
`setInequality`	Set up linear inequality constraints for portfolio weights
`setBounds`	Set up bounds for portfolio weights for portfolio
`setMinMaxNumAssets`	Set cardinality constraints on the number of assets invested in a portfolio
`setBudget`	Set up budget constraints for portfolio
`setCosts`	Set up proportional transaction costs for portfolio
`setDefaultConstraints`	Set up portfolio constraints with nonnegative weights that sum to 1
`setEquality`	Set up linear equality constraints for portfolio weights
`setGroupRatio`	Set up group ratio constraints for portfolio weights
`setInitPort`	Set up initial or current portfolio
`setOneWayTurnover`	Set up one-way portfolio turnover constraints
`setTurnover`	Set up maximum portfolio turnover constraint
`checkFeasibility`	Check feasibility of input portfolios against portfolio object
`estimateBounds`	Estimate global lower and upper bounds for set of portfolios
`estimateFrontier`	Estimate specified number of optimal portfolios on the efficient frontier
`estimateFrontierByReturn`	Estimate optimal portfolios with targeted portfolio returns
`estimateFrontierByRisk`	Estimate optimal portfolios with targeted portfolio risks
`estimateFrontierLimits`	Estimate optimal portfolios at endpoints of efficient frontier
`plotFrontier`	Plot efficient frontier
`estimatePortReturn`	Estimate mean of portfolio returns
`estimatePortRisk`	Estimate portfolio risk according to risk proxy associated with corresponding object
`setSolver`	Choose main solver and specify associated solver options for portfolio optimization
`setProbabilityLevel`	Set probability level for VaR and CVaR calculations
`setScenarios`	Set asset returns scenarios by direct matrix
`getScenarios`	Obtain scenarios from portfolio object
`simulateNormalScenariosByData`	Simulate multivariate normal asset return scenarios from data
`simulateNormalScenariosByMoments`	Simulate multivariate normal asset return scenarios from mean and covariance of asset returns
`estimateScenarioMoments`	Estimate mean and covariance of asset return scenarios
`estimatePortVaR`	Estimate value-at-risk for PortfolioCVaR object
`estimatePortStd`	Estimate standard deviation of portfolio returns

Examples

collapse all

Create an Empty PortfolioCVaR Object

Open Live Script

You can create a PortfolioCVaR object, p, with no input arguments and display it using disp.

p = PortfolioCVaR;
disp(p);

  PortfolioCVaR with properties:

             BuyCost: []
            SellCost: []
        RiskFreeRate: []
    ProbabilityLevel: []
            Turnover: []
         BuyTurnover: []
        SellTurnover: []
        NumScenarios: []
                Name: []
           NumAssets: []
           AssetList: []
            InitPort: []
         AInequality: []
         bInequality: []
           AEquality: []
           bEquality: []
          LowerBound: []
          UpperBound: []
         LowerBudget: []
         UpperBudget: []
         GroupMatrix: []
          LowerGroup: []
          UpperGroup: []
              GroupA: []
              GroupB: []
          LowerRatio: []
          UpperRatio: []
        MinNumAssets: []
        MaxNumAssets: []
           BoundType: []

This approach provides a way to set up a portfolio optimization problem with the PortfolioCVaR function. You can then use the associated set functions to set and modify collections of properties in the PortfolioCVaR object.

Create a PortfolioCVaR Object Using a Single-Step Setup

Open Live Script

You can use the PortfolioCVaR object directly to set up a “standard” portfolio optimization problem. Given scenarios of asset returns in the variable AssetScenarios, this problem is completely specified as follows:

m = [ 0.05; 0.1; 0.12; 0.18 ];
C = [ 0.0064 0.00408 0.00192 0; 
    0.00408 0.0289 0.0204 0.0119;
    0.00192 0.0204 0.0576 0.0336;
    0 0.0119 0.0336 0.1225 ];
m = m/12;
C = C/12;

AssetScenarios = mvnrnd(m, C, 20000);

p = PortfolioCVaR('Scenarios', AssetScenarios, ...
'LowerBound', 0, 'LowerBudget', 1, 'UpperBudget', 1, ...
'ProbabilityLevel', 0.95)

p = 
  PortfolioCVaR with properties:

             BuyCost: []
            SellCost: []
        RiskFreeRate: []
    ProbabilityLevel: 0.9500
            Turnover: []
         BuyTurnover: []
        SellTurnover: []
        NumScenarios: 20000
                Name: []
           NumAssets: 4
           AssetList: []
            InitPort: []
         AInequality: []
         bInequality: []
           AEquality: []
           bEquality: []
          LowerBound: [4x1 double]
          UpperBound: []
         LowerBudget: 1
         UpperBudget: 1
         GroupMatrix: []
          LowerGroup: []
          UpperGroup: []
              GroupA: []
              GroupB: []
          LowerRatio: []
          UpperRatio: []
        MinNumAssets: []
        MaxNumAssets: []
           BoundType: []

Note that the LowerBound property value undergoes scalar expansion since AssetScenarios provides the dimensions of the problem.

Create a PortfolioCVaR Object Using a Sequence of Steps

Open Live Script

Using a sequence of steps is an alternative way to accomplish the same task of setting up a “standard” CVaR portfolio optimization problem, given AssetScenarios variable is:

m = [ 0.05; 0.1; 0.12; 0.18 ];
C = [ 0.0064 0.00408 0.00192 0;
0.00408 0.0289 0.0204 0.0119;
0.00192 0.0204 0.0576 0.0336;
0 0.0119 0.0336 0.1225 ];

m = m/12;
C = C/12;

AssetScenarios = mvnrnd(m, C, 20000);

p = PortfolioCVaR;
p = setScenarios(p, AssetScenarios);
p = PortfolioCVaR(p, 'LowerBound', 0);
p = PortfolioCVaR(p, 'LowerBudget', 1, 'UpperBudget', 1);
p = setProbabilityLevel(p, 0.95);

plotFrontier(p);

Figure contains an axes object. The axes object with title Efficient Frontier, xlabel Conditional Value-at-Risk of Portfolio, ylabel Mean of Portfolio Returns contains an object of type line.

This way works because the calls to PortfolioCVaR are in this particular order. In this case, the call to initialize AssetScenarios provides the dimensions for the problem. If you were to do this step last, you would have to explicitly dimension the LowerBound property as follows:

m = [ 0.05; 0.1; 0.12; 0.18 ];
C = [ 0.0064 0.00408 0.00192 0;
0.00408 0.0289 0.0204 0.0119;
0.00192 0.0204 0.0576 0.0336;
0 0.0119 0.0336 0.1225 ];

m = m/12;
C = C/12;

AssetScenarios = mvnrnd(m, C, 20000);

p = PortfolioCVaR;
p = PortfolioCVaR(p, 'LowerBound', zeros(size(m)));
p = PortfolioCVaR(p, 'LowerBudget', 1, 'UpperBudget', 1);
p = setProbabilityLevel(p, 0.95);
p = setScenarios(p, AssetScenarios); 

plotFrontier(p);

Figure contains an axes object. The axes object with title Efficient Frontier, xlabel Conditional Value-at-Risk of Portfolio, ylabel Mean of Portfolio Returns contains an object of type line.

If you did not specify the size of LowerBound but, instead, input a scalar argument, the PortfolioCVaR object assumes that you are defining a single-asset problem and produces an error at the call to set asset scenarios with four assets.

Create a PortfolioCVaR Object Using Shortcuts for Property Names

Open Live Script

You can create a PortfolioCVaR object, p with the PortfolioCVaR object using shortcuts for property names.

m = [ 0.05; 0.1; 0.12; 0.18 ];
C = [ 0.0064 0.00408 0.00192 0;
0.00408 0.0289 0.0204 0.0119;
0.00192 0.0204 0.0576 0.0336;
0 0.0119 0.0336 0.1225 ];

m = m/12;
C = C/12;

AssetScenarios = mvnrnd(m, C, 20000);

p = PortfolioCVaR('scenario', AssetScenarios, 'lb', 0, 'budget', 1, 'plevel', 0.95)

p = 
  PortfolioCVaR with properties:

             BuyCost: []
            SellCost: []
        RiskFreeRate: []
    ProbabilityLevel: 0.9500
            Turnover: []
         BuyTurnover: []
        SellTurnover: []
        NumScenarios: 20000
                Name: []
           NumAssets: 4
           AssetList: []
            InitPort: []
         AInequality: []
         bInequality: []
           AEquality: []
           bEquality: []
          LowerBound: [4x1 double]
          UpperBound: []
         LowerBudget: 1
         UpperBudget: 1
         GroupMatrix: []
          LowerGroup: []
          UpperGroup: []
              GroupA: []
              GroupB: []
          LowerRatio: []
          UpperRatio: []
        MinNumAssets: []
        MaxNumAssets: []
           BoundType: []

Direct Setting of PortfolioCVaR Object Properties

Open Live Script

Although not recommended, you can set properties directly, however no error-checking is done on your inputs.

m = [ 0.05; 0.1; 0.12; 0.18 ];
C = [ 0.0064 0.00408 0.00192 0; 
    0.00408 0.0289 0.0204 0.0119;
    0.00192 0.0204 0.0576 0.0336;
    0 0.0119 0.0336 0.1225 ];
m = m/12;
C = C/12;

AssetScenarios = mvnrnd(m, C, 20000);

p = PortfolioCVaR;

p = setScenarios(p, AssetScenarios);
p.ProbabilityLevel = 0.95;

p.LowerBudget = 1;
p.UpperBudget = 1;
p.LowerBound = zeros(size(m));
disp(p)

  PortfolioCVaR with properties:

             BuyCost: []
            SellCost: []
        RiskFreeRate: []
    ProbabilityLevel: 0.9500
            Turnover: []
         BuyTurnover: []
        SellTurnover: []
        NumScenarios: 20000
                Name: []
           NumAssets: 4
           AssetList: []
            InitPort: []
         AInequality: []
         bInequality: []
           AEquality: []
           bEquality: []
          LowerBound: [4x1 double]
          UpperBound: []
         LowerBudget: 1
         UpperBudget: 1
         GroupMatrix: []
          LowerGroup: []
          UpperGroup: []
              GroupA: []
              GroupB: []
          LowerRatio: []
          UpperRatio: []
        MinNumAssets: []
        MaxNumAssets: []
           BoundType: []

Scenarios cannot be assigned directly to a PortfolioCVaR object. Scenarios must always be set through either the PortfolioCVaR function, the setScenarios function, or any of the scenario simulation functions.

Construct a PortfolioCVaR Object and Determine Efficient Portfolios

Open Live Script

Create efficient portfolios:

load CAPMuniverse

p = PortfolioCVaR('AssetList',Assets(1:12));
p = simulateNormalScenariosByData(p, Data(:,1:12), 20000 ,'missingdata',true);
p = setDefaultConstraints(p);
p = setProbabilityLevel(p, 0.95);

plotFrontier(p);

Figure contains an axes object. The axes object with title Efficient Frontier, xlabel Conditional Value-at-Risk of Portfolio, ylabel Mean of Portfolio Returns contains an object of type line.

pwgt = estimateFrontier(p, 5);

pnames = cell(1,5);
for i = 1:5
	pnames{i} = sprintf('Port%d',i);
end

Blotter = dataset([{pwgt},pnames],'obsnames',p.AssetList);

disp(Blotter);

            Port1       Port2        Port3       Port4      Port5
    AAPL     0.01024     0.073698     0.11968    0.12961    0    
    AMZN           0            0           0          0    0    
    CSCO           0            0           0          0    0    
    DELL     0.02161            0           0          0    0    
    EBAY           0            0           0          0    0    
    GOOG     0.20311      0.38012     0.56206    0.75948    1    
    HPQ     0.042472    0.0092573           0          0    0    
    IBM      0.44453       0.3638     0.26262    0.11092    0    
    INTC           0            0           0          0    0    
    MSFT     0.27805      0.17313    0.055642          0    0    
    ORCL           0            0           0          0    0    
    YHOO           0            0           0          0    0

Mixed-Integer CVaR Portfolio Optimization Problem

Open Live Script

This example shows how to solve a CVaR portfolio optimization problem with constraints in the number of selected assets or conditional (semicontinuous) bounds. To solve this problem, you can use a PortfolioCVaR object along with different mixed integer nonlinear programming (MINLP) solvers.

CVaR Portfolio

Load the returns data in CAPMuniverse.mat. Then, create a PortfolioCVaR object with default constraints and a long-only portfolio whose weights sum to 1. For this example, you can define the feasible region of weights $X$ as

$X = {x | \sum_{i = 1}^{n} x_{i} = 1, x_{i} \geq 0} .$

% Load data
load CAPMuniverse.mat

% Create portfolio with default constraints
p = PortfolioCVaR(ProbabilityLevel=0.95);
p = simulateNormalScenariosByData(p,Data(:,1:12),1000,missingdata=true);
p = setDefaultConstraints(p);

Include binary variables for this scenario by setting conditional (semicontinuous) bounds. Conditional bounds are those such that $x_{i} = 0$ or $x_{i} \geq ℓ_{i}$ . In this example, $ℓ_{i} = 0.1$ for all assets.

% Set conditional bounds
condLB = 0.1;
condUB = 0.5;
p = setBounds(p,condLB,condUB,BoundType="conditional");

Use estimateFrontier to estimate a set of portfolios on the efficient frontier. The efficient frontier is a curve that shows the trade-off between the return and risk achieved by Pareto-optimal portfolios. For a given return level, the portfolio on the efficient frontier is the one that minimizes the risk while maintaining the desired return. Conversely, for a given risk level, the portfolio on the efficient frontier is the one that maximizes return while maintaining the desired risk level.

% Compute efficient frontier
p = setSolverMINLP(p,'TrustRegionCP',DeltaLowerBound=condLB);
pwgt = estimateFrontier(p)

pwgt = 12×10

         0         0         0         0         0         0         0         0         0         0
         0         0         0         0         0         0         0         0         0         0
         0         0         0         0         0         0         0         0         0         0
    0.1000    0.1094    0.1000    0.1000         0         0         0         0         0         0
         0         0         0    0.1000    0.1662    0.2634    0.3369    0.4051    0.4647    0.5000
    0.1328    0.2387    0.3331    0.3263    0.3622    0.3543    0.3701    0.3854    0.4287    0.5000
    0.1000         0         0         0         0         0         0         0         0         0
    0.4132    0.3888    0.2755    0.2552    0.2288    0.1812    0.1110         0         0         0
         0         0         0         0         0         0         0         0         0         0
    0.2540    0.2631    0.2914    0.2185    0.2427    0.2011    0.1821    0.2095    0.1067         0
      ⋮

% Compute risk and returns of the portfolios on the efficient frontier
rsk = estimatePortRisk(p,pwgt)

ret = estimatePortReturn(p,pwgt)

Plot the weights from the frontier estimation using plotFrontier. The resulting curve is piece-wise concave with possible vertical jumps (discontinuities) between the concave intervals.

% Plot efficient frontier
plotFrontier(p,pwgt)

Figure contains an axes object. The axes object with title Efficient Frontier, xlabel Conditional Value-at-Risk of Portfolio, ylabel Mean of Portfolio Returns contains an object of type line.

Changing MINLP Solvers

In the previous section, you use the default solver for estimateFrontier. However, you can solve mixed-integer portfolio problems using any of the three algorithms supported by setSolverMINLP: OuterApproximation, ExtendedCP, and TrustRegionCP. Furthermore, the OuterApproximation algorithm accepts an additional name-value argument (ExtendedFormulation) for Portfolio problems, which reformulates problems with quadratic functions to work in an extended space that usually decreases the computation time. All algorithms, including the extended formulation variation of the OuterApproximation algorithm, return the same values within numerical accuracy. The available solvers are:

OuterApproximation — The default algorithm, which is robust and usually faster than ExtenedCP
OuterApproximation with ExtendedFormulation set to true — A robust algorithm that is usually faster than other algorithms, but only supported for Portfolio object problems
ExtendedCP — The most robust solver, but usually the slowest
TrustRegionCP — The fastest algorithm, but one that is less robust and may provide suboptimal solutions

For more information on solvers for mixed-integer portfolio problems, see Choose MINLP Solvers for Portfolio Problems.

To change the MINLP solvers, use setSolverMINLP.

% Select 'TrustRegionCP' as solver
p_OA = setSolverMINLP(p,'OuterApproximation');
pwgt_OA = estimateFrontier(p_OA);
rskOA = estimatePortRisk(p,pwgt_OA);
retOA = estimatePortReturn(p,pwgt_OA);

% Select 'ExtendedCP' as solver using 'midway' cuts as 'CutGeneration'
p_ECP = setSolverMINLP(p,'ExtendedCP',CutGeneration="midway");
pwgt_ECP = estimateFrontier(p_ECP);
rskECP = estimatePortRisk(p,pwgt_ECP);
retECP = estimatePortReturn(p,pwgt_ECP);

Compare the returns and risks obtained by the portfolios on the efficient frontier from the different solvers. They are all the same within a numerical accuracy that is an absolute difference $\leq 10^{- 4}$ .

retTable = table(retOA,ret,retECP,'VariableNames',{'OA','TR','ECP'})

retTable=10×3 table
        OA            TR           ECP    
    __________    __________    __________

    0.00092881    0.00092876    0.00092876
     0.0011614     0.0011613     0.0011613
      0.001394     0.0013939     0.0013939
     0.0016265     0.0016265     0.0016265
     0.0018591     0.0018591     0.0018591
     0.0020917     0.0020917     0.0020917
     0.0023243     0.0023243     0.0023243
     0.0025569     0.0025569     0.0025569
     0.0027894     0.0027894     0.0027894
      0.003022      0.003022      0.003022

rskTable = table(rskOA,rsk,rskECP,'VariableNames',{'OA','TR','ECP'})

rskTable=10×3 table
       OA          TR         ECP   
    ________    ________    ________

    0.036808    0.036808    0.036808
    0.037658    0.037658    0.037658
    0.039808    0.039808    0.039808
    0.042256    0.042256    0.042256
     0.04527    0.045269    0.045269
    0.048489    0.048488    0.048488
    0.051963    0.051963    0.051963
    0.055783    0.055783    0.055783
    0.059828    0.059828    0.059828
    0.064705    0.064705    0.064705

% Compare risks from the different OuterApproximation formulations
norm(rskTable.OA-rskTable.TR,Inf) <= 1e-4

ans = logical
   1

More About

expand all

Conditional Value-at-Risk Portfolio Optimization

A CVaR optimization problem is completely specified with four elements.

The four elements for a CVaR optimization problem are:

A universe of assets with scenarios of asset total returns for a period of interest, where scenarios comprise a collection of samples from the underlying probability distribution for asset total returns. This collection must be sufficiently large for asymptotic convergence of sample statistics. Asset return moments and related statistics are derived exclusively from the scenarios.
A portfolio set that specifies the set of portfolio choices in terms of a collection of constraints.
A model for portfolio return and risk proxies, which, for CVaR optimization, is either the gross or net mean of portfolio returns and the conditional value-at-risk of portfolio returns.
A probability level that specifies the probability that a loss is less than or equal to the value-at-risk. Typical values are 0.9 and 0.95, which indicate 10% and 5% loss probabilities.

After these four elements have been specified in an unambiguous way, it is possible to solve and analyze CVaR portfolio optimization problems.

The simplest CVaR portfolio optimization problem has:

Scenarios of asset total returns
A requirement that all portfolios have nonnegative weights that sum to 1 (the summation constraint is known as a budget constraint)
Built-in models for portfolio return and risk proxies that use scenarios of asset total returns
A probability level of 0.95

Given scenarios of asset returns in the variable AssetScenarios, this problem is completely specified by:

p = PortfolioCVaR('Scenarios', AssetScenarios, 'LowerBound', 0, 'Budget', 1, ...
'ProbabilityLevel', 0.95);

or equivalently by:

p = PortfolioCVaR;
p = setScenarios(p, AssetScenarios);
p = setDefaultConstraints(p);
p = setProbabilityLevel(p, 0.95);

To confirm that this is a valid portfolio optimization problem, the following function determines whether the set of PortfolioCVaR choices is bounded (a necessary condition for portfolio optimization).

[lb, ub, isbounded] = estimateBounds(p);

Given the problem specified in the PortfolioCVaR object p, the efficient frontier for this problem can be displayed with:

plotFrontier(p);

and efficient portfolios can be obtained with:

pwgt = estimateFrontier(p);

For more information on the theory and definition of conditional value-at-risk optimization supported by portfolio optimization tools in Financial Toolbox™, see Portfolio Optimization Theory.

PortfolioCVaR Problem Sufficiency

A CVaR portfolio optimization problem is completely specified with the PortfolioCVaR object if three conditions are met.

The following are the three conditions that must be met:

You must specify a collection of asset returns or prices known as scenarios such that all scenarios are finite asset returns or prices. These scenarios are meant to be samples from the underlying probability distribution of asset returns. This condition can be satisfied by the setScenarios function or with several canned scenario simulation functions.
The set of feasible portfolios must be a nonempty compact set, where a compact set is closed and bounded. You can satisfy this condition using an extensive collection of properties that define different types of constraints to form a set of feasible portfolios. Since such sets must be bounded, either explicit or implicit constraints can be imposed and several tools, such as the estimateBounds function, provide ways to ensure that your problem is properly formulated.
You must specify a probability level to locate the level of tail loss above which the conditional value-at-risk is to be minimized. This condition can be satisfied by the setProbabilityLevel function.
Although the general sufficient conditions for CVaR portfolio optimization go beyond the first three conditions, the PortfolioCVaR object handles all these additional conditions.

Shortcuts for Property Names

The PortfolioCVaR object has shorter argument names that replace longer argument names associated with specific properties of the PortfolioCVaR object.

For example, rather than enter 'ProbabilityLevel', the PortfolioCVaR object accepts the case-insensitive name 'plevel' to set the ProbabilityLevel property in a PortfolioCVaR object. Every shorter argument name corresponds with a single property in the PortfolioCVaR object. The one exception is the alternative argument name 'budget', which signifies both the LowerBudget and UpperBudget properties. When 'budget' is used, then the LowerBudget and UpperBudget properties are set to the same value to form an equality budget constraint.

Shortcuts for Property Names

Shortcut Argument Name	Equivalent Argument / Property Name
`ae`	`AEquality`
`ai`	`AInequality`
`assetnames` or `assets`	`AssetList`
`be`	`bEquality`
`bi`	`bInequality`
`budget`	`UpperBudget` and `LowerBudget`
`group`	`GroupMatrix`
`lb`	`LowerBound`
`n` or `num`	`NumAssets`
`level`, `problevel`, or `plevel`	`ProbabilityLevel`
`rfr`	`RiskFreeRate`
`scenario` or `assetscenarios`	`Scenarios`
`ub`	`UpperBound`

References

[1] For a complete list of references for the PortfolioCVaR object, see Portfolio Optimization.

Version History

Introduced in R2012b

PortfolioCVaR

Description

Creation

Syntax

Description

Input Arguments

p — Previously constructed PortfolioCVaR object object

Properties

Setting Up the PortflioCVaR Object

AssetList — Names or symbols of assets in universe [] (default) | cell array of character vectors | string array

InitPort — Initial portfolio [] (default) | vector

Name — Name for instance of PortfolioCVaR object [] (default) | character vector | string

NumAssets — Number of assets in the universe [] (default) | integer scalar

PortfolioCVaR Object Constraints

AEquality — Linear equality constraint matrix [] (default) | matrix

AInequality — Linear inequality constraint matrix [] (default) | matrix

bEquality — Linear equality constraint vector [] (default) | vector

bInequality — Linear inequality constraint [] (default) | vector

GroupA — Group A weights to be bounded by weights in group B [] (default) | matrix

GroupB — Group B weights [] (default) | matrix

GroupMatrix — Group membership matrix [] (default) | matrix

LowerBound — Lower-bound constraint [] (default) | vector

LowerBudget — Lower-bound budget constraint [] (default) | scalar

LowerGroup — Lower-bound group constraint [] (default) | vector

LowerRatio — Minimum ratio of allocations between Groups A and B [] (default) | vector

UpperBound — Upper-bound constraint [] (default) | vector

UpperBudget — Upper-bound budget constraint [] (default) | scalar

UpperGroup — Upper-bound group constraint [] (default) | vector

UpperRatio — Maximum ratio of allocations between Groups A and B [] (default) | vector

BoundType — Type of bounds for each asset weight 'Simple' (default) | character vector with value 'Simple' or 'Conditional' | string with value "Simple" or "Conditional" | cell array of character vectors with values 'Simple' or 'Conditional' | string array with values "Simple" or "Conditional"

MinNumAssets — Minimum number of assets allocated in portfolio [] (default) | numeric

MaxNumAssets — Maximum number of assets allocated in portfolio [] (default) | numeric

Turnover — Turnover constraint [] (default) | scalar

SellTurnover — Turnover constraint on sales [] (default) | scalar

BuyTurnover — Turnover constraint on purchases [] (default) | scalar

PortfolioCVaR Object Modeling

BuyCost — Proportional purchase costs [] (default) | vector

RiskFreeRate — Risk-free rate [] (default) | scalar

ProbabilityLevel — Value-at-risk probability level which is 1 − (loss probability) [] (default) | scalar

NumScenarios — Number of scenarios [] (default) | integer scalar

SellCost — Proportional sales costs [] (default) | vector

Object Functions

Examples

Create an Empty PortfolioCVaR Object

Create a PortfolioCVaR Object Using a Single-Step Setup

Create a PortfolioCVaR Object Using a Sequence of Steps

Create a PortfolioCVaR Object Using Shortcuts for Property Names

Direct Setting of PortfolioCVaR Object Properties

Construct a PortfolioCVaR Object and Determine Efficient Portfolios

Mixed-Integer CVaR Portfolio Optimization Problem

More About

Conditional Value-at-Risk Portfolio Optimization

PortfolioCVaR Problem Sufficiency

Shortcuts for Property Names

References

Version History

See Also

Topics

External Websites

`p` — Previously constructed PortfolioCVaR object
object

`AssetList` — Names or symbols of assets in universe
`[]` (default) | cell array of character vectors | string array

`InitPort` — Initial portfolio
`[]` (default) | vector

`Name` — Name for instance of PortfolioCVaR object
`[]` (default) | character vector | string

`NumAssets` — Number of assets in the universe
`[]` (default) | integer scalar

`AEquality` — Linear equality constraint matrix
`[]` (default) | matrix

`AInequality` — Linear inequality constraint matrix
`[]` (default) | matrix

`bEquality` — Linear equality constraint vector
`[]` (default) | vector

`bInequality` — Linear inequality constraint
`[]` (default) | vector

`GroupA` — Group A weights to be bounded by weights in group B
`[]` (default) | matrix

`GroupB` — Group B weights
`[]` (default) | matrix

`GroupMatrix` — Group membership matrix
`[]` (default) | matrix

`LowerBound` — Lower-bound constraint
`[]` (default) | vector

`LowerBudget` — Lower-bound budget constraint
`[]` (default) | scalar

`LowerGroup` — Lower-bound group constraint
`[]` (default) | vector

`LowerRatio` — Minimum ratio of allocations between Groups A and B
`[]` (default) | vector

`UpperBound` — Upper-bound constraint
`[]` (default) | vector

`UpperBudget` — Upper-bound budget constraint
`[]` (default) | scalar

`UpperGroup` — Upper-bound group constraint
`[]` (default) | vector

`UpperRatio` — Maximum ratio of allocations between Groups A and B
`[]` (default) | vector

`MinNumAssets` — Minimum number of assets allocated in portfolio
`[]` (default) | numeric

`MaxNumAssets` — Maximum number of assets allocated in portfolio
`[]` (default) | numeric

`Turnover` — Turnover constraint
`[]` (default) | scalar

`SellTurnover` — Turnover constraint on sales
`[]` (default) | scalar

`BuyTurnover` — Turnover constraint on purchases
`[]` (default) | scalar

`BuyCost` — Proportional purchase costs
`[]` (default) | vector

`RiskFreeRate` — Risk-free rate
`[]` (default) | scalar

`ProbabilityLevel` — Value-at-risk probability level which is 1 − (loss probability)
`[]` (default) | scalar

`NumScenarios` — Number of scenarios
`[]` (default) | integer scalar

`SellCost` — Proportional sales costs
`[]` (default) | vector