Note: This page has been translated by MathWorks. Please click here

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

The Portfolio object implements mean-variance portfolio optimization.
Every property and function of the Portfolio object is public, although
some properties and functions are hidden. See `Portfolio`

for
the properties and functions of the Portfolio object. The Portfolio
object is a value object where every instance of the object is a distinct
version of the object. Since the Portfolio object is also a MATLAB^{®} object,
it inherits the default functions associated with MATLAB objects.

The Portfolio object and its functions are an interface for mean-variance portfolio optimization. So, almost everything you do with the Portfolio object can be done using the associated functions. The basic workflow is:

Design your portfolio problem.

Use the

`Portfolio`

function to create the Portfolio 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 Portfolio 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 mean-variance portfolio
optimization, means that you have either data or moments for asset
returns and a collection of constraints on your portfolios, use the `Portfolio`

function to set the properties
for the Portfolio object. The `Portfolio`

function
lets you create an object from scratch or update an existing object.
Since the Portfolio 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 Portfolio Object.

You can set properties of a Portfolio object using either the `Portfolio`

function 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 `Portfolio`

function
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 `AssetMean`

and `AssetCovar`

properties
in an existing Portfolio object `p`

with the values `m`

and `C`

,
use the syntax:

p = Portfolio(p, 'AssetMean', m, 'AssetCovar', C);

In addition to the `Portfolio`

function,
which lets you set individual properties one at a time, groups of
properties are set in a Portfolio 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 average turnover and the initial
portfolio. To get individual properties from a Portfolio object, obtain
properties directly or use an assortment of “get” functions
that obtain groups of properties from a Portfolio object. The `Portfolio`

function and set functions
have several useful features:

The

`Portfolio`

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

`Portfolio`

function and set functions try to resolve ambiguities with default choices.The

`Portfolio`

function and set functions perform scalar expansion on arrays when possible.The associated Portfolio object functions try to diagnose and warn about problems.

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

and `disp`

display
a Portfolio object and its properties with or without the object variable
name.

Save and load Portfolio objects using the MATLAB `save`

and `load`

commands.

Estimating efficient portfolios and efficient frontiers is the primary purpose of the portfolio optimization tools. 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 Portfolio object are
designed to work on a scalar Portfolio object, the array capabilities
of MATLAB enables you to set up and work with arrays of Portfolio
objects. The easiest way to do this is with the `repmat`

function. For example, to create
a 3-by-2 array of Portfolio objects:

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

p(i,j) = Portfolio(p(i,j), ... );

`Portfolio`

function
for the (`i`

,`j`

) element of a matrix
of Portfolio objects in the variable `p`

.If you set up an array of Portfolio objects, you can access
properties of a particular Portfolio 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 Portfolio objects with

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

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

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

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

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

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 portfolio optimization tools follow these conventions regarding the representation of different quantities associated with portfolio optimization:

Asset returns or prices 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.

The mean and covariance of asset returns are stored in a vector and a matrix and the tools have no requirement that the mean must be either a column or row vector.

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).

- Creating the Portfolio Object
- Working with Portfolio Constraints Using Defaults
- Asset Allocation Case Study
- Portfolio Optimization Examples

Was this topic helpful?