The `PortfolioCVaR`

object implements conditional value-at-risk
(CVaR) portfolio optimization. Every property and function of the
`PortfolioCVaR`

object is public, although some properties and
functions are hidden. See`PortfolioCVaR`

for the properties and
functions of a `PortfolioCVaR`

object. The
`PortfolioCVaR`

object is a value object where every instance
of the object is a distinct version of the object. Since the
`PortfolioCVaR`

object is also a MATLAB^{®} object, it inherits the default functions associated with MATLAB objects.

The `PortfolioCVaR`

object and its functions are an interface for
conditional value-at-risk portfolio optimization. So, almost everything you do with
the `PortfolioCVaR`

object can be done using the functions. The
basic workflow is:

Design your portfolio problem.

Use

`PortfolioCVaR`

to create the`PortfolioCVaR`

object or use the various set functions to set up your portfolio problem.Use estimate functions to solve your portfolio problem.

In addition, functions are available to help you view intermediate
results and to diagnose your computations. Since MATLAB features are part of a `PortfolioCVaR`

object, you
can save and load objects from your workspace and create and manipulate arrays of
objects. After settling on a problem, which, in the case of CVaR portfolio
optimization, means that you have either scenarios, data, or moments for asset
returns, a probability level, and a collection of constraints on your portfolios,
use `PortfolioCVaR`

to set the properties
for the `PortfolioCVaR`

object.

`PortfolioCVaR`

lets you create an
object from scratch or update an existing object. Since the
`PortfolioCVaR`

object is a value object, it is easy to create
a basic object, then use functions to build upon the basic object to create new
versions of the basic object. This is useful to compare a basic problem with
alternatives derived from the basic problem. For details, see Creating the PortfolioCVaR Object.

You can set properties of a `PortfolioCVaR`

object using either
the `PortfolioCVaR`

object or various
`set`

functions.

Although you can also set properties directly, it is not recommended since error-checking is not performed when you set a property directly.

The `PortfolioCVaR`

object supports setting
properties with name-value pair arguments such that each argument name is a property
and each value is the value to assign to that property. For example, to set the
`LowerBound`

, `Budget`

, and
`ProbabilityLevel`

properties in an existing
`PortfolioCVaR`

object `p`

, use the
syntax:

p = PortfolioCVaR(p,'LowerBound', 0, 'Budget', 'ProbabilityLevel', 0.95);

In addition to the `PortfolioCVaR`

object, which lets you
set individual properties one at a time, groups of properties are set in a
`PortfolioCVaR`

object with various “set” and
“add” functions. For example, to set up an average turnover
constraint, use the `setTurnover`

function to specify the
bound on portfolio turnover and the initial portfolio. To get individual properties
from a `PortfolioCVaR`

object, obtain properties directly or use an
assortment of “get” functions that obtain groups of properties from a
`PortfolioCVaR`

object. The `PortfolioCVaR`

object and
`set`

functions have several useful features:

The

`PortfolioCVaR`

object and`set`

functions try to determine the dimensions of your problem with either explicit or implicit inputs.The

`PortfolioCVaR`

object and`set`

functions try to resolve ambiguities with default choices.The

`PortfolioCVaR`

object and`set`

functions perform scalar expansion on arrays when possible.The CVaR functions try to diagnose and warn about problems.

The `PortfolioCVaR`

object uses the default display functions
provided by MATLAB, where `display`

and `disp`

display
a `PortfolioCVaR`

object and its properties with or without the
object variable name.

Save and load `PortfolioCVaR`

objects using the MATLAB
`save`

and `load`

commands.

Estimating efficient portfolios and efficient frontiers is the primary purpose of
the CVaR portfolio optimization tools. An *efficient portfolio*
is the portfolios that satisfy the criteria of minimum risk for a given level of
return and maximum return for a given level of risk. A collection of
“estimate” and “plot” functions provide ways to explore
the efficient frontier. The “estimate” functions obtain either
efficient portfolios or risk and return proxies to form efficient frontiers. At the
portfolio level, a collection of functions estimates efficient portfolios on the
efficient frontier with functions to obtain efficient portfolios:

At the endpoints of the efficient frontier

That attain targeted values for return proxies

That attain targeted values for risk proxies

Along the entire efficient frontier

These functions also provide purchases and sales needed to shift from an initial or current portfolio to each efficient portfolio. At the efficient frontier level, a collection of functions plot the efficient frontier and estimate either risk or return proxies for efficient portfolios on the efficient frontier. You can use the resultant efficient portfolios or risk and return proxies in subsequent analyses.

Although all functions associated with a `PortfolioCVaR`

object
are designed to work on a scalar `PortfolioCVaR`

object, the array
capabilities of MATLAB enables you to set up and work with arrays of
`PortfolioCVaR`

objects. The easiest way to do this is with the
`repmat`

function. For example, to
create a 3-by-2 array of `PortfolioCVaR`

objects:

p = repmat(PortfolioCVaR, 3, 2); disp(p)

`PortfolioCVaR`

objects, you can work on
individual `PortfolioCVaR`

objects in the array by indexing. For
example:p(i,j) = PortfolioCVaR(p(i,j), ... );

`PortfolioCVaR`

for the
(`i`

,`j`

) element of a matrix of
`PortfolioCVaR`

objects in the variable
`p`

.If you set up an array of `PortfolioCVaR`

objects, you can access
properties of a particular `PortfolioCVaR`

object in the array by
indexing so that you can set the lower and upper bounds `lb`

and
`ub`

for the
(`i`

,`j`

,`k`

) element of a
3-D array of `PortfolioCVaR`

objects
with

p(i,j,k) = setBounds(p(i,j,k), lb, ub);

[lb, ub] = getBounds(p(i,j,k));

`PortfolioCVaR`

object functions work on only one `PortfolioCVaR`

object at a
time.You can subclass the `PortfolioCVaR`

object to override existing
functions or to add new properties or functions. To do so, create a derived class
from the `PortfolioCVaR`

class. This gives you all the properties
and functions of the`PortfolioCVaR`

class along with any new
features that you choose to add to your subclassed object.
The`PortfolioCVaR`

class is derived from an abstract class
called `AbstractPortfolio`

. Because of this, you can also create a
derived class from `AbstractPortfolio`

that implements an entirely
different form of portfolio optimization using properties and functions of
the`AbstractPortfolio`

class.

The CVaR portfolio optimization tools follow these conventions regarding the representation of different quantities associated with portfolio optimization:

Asset returns or prices for scenarios are in matrix form with samples for a given asset going down the rows and assets going across the columns. In the case of prices, the earliest dates must be at the top of the matrix, with increasing dates going down.

Portfolios are in vector or matrix form with weights for a given portfolio going down the rows and distinct portfolios going across the columns.

Constraints on portfolios are formed in such a way that a portfolio is a column vector.

Portfolio risks and returns are either scalars or column vectors (for multiple portfolio risks and returns).