Application Center - Maplesoft

App Preview:

Portfolio Optimization with the Omega Ratio

You can switch back to the summary page by clicking here.

Learn about Maple
Download Application




Portfolio Optimization with the Omega Ratio

 

Introduction

 

 

Traditional investment performance benchmarks, like the Sharpe Ratio, approximate the returns distribution with mean and standard deviation. This, however, assumes the distribution is normal.  Many modern investments vehicles, like hedge funds, display fat tails, and skew and kurtosis in the returns distribution. Hence, they cannot be adequately benchmarked with traditional approaches.

 

One solution, proposed by Shadwick and Keating in 2002 is the Omega Ratio.  This divides the returns distribution into two halves – the area below a target return, and the above a target return. The Omega Ratio is simply the former divided by the latter. A higher value is better.

 

For a set of discrete returns, the Omega Ratio is given by

 

Omega(L) = E[max(R-L, 0)]/E[max(L-R, 0)]

 

where L is a target return and R is a vector of returns.

 

This application finds the asset weights that maximize the Omega Ratio of a portfolio of ten investments, given their simulated monthly returns and a target return.

 

This is a non-convex problem, and requires global optimizers for a rigorous solution. However, a transformation of the variables (only valid for Omega Ratios of over 1) converts the optimization into a linear program.

 

This application implements both approaches, the former using Maple's Global Optimization Toolbox, and the latter using Maple's linear programming features. For the data set provided in this application, both approaches give comparible results.

 

Returns Data and Minimum Acceptable Return

 

restart

Monthly hedge fund returns

Number of funds

N := LinearAlgebra[ColumnDimension](data)

10

(2.1)

Number of returns for each fund

S := LinearAlgebra[RowDimension](data)

36

(2.2)

Target Return

L := .1

Omega Ratio

 

OmegaRatio := proc (L, returns, weights) local weightedReturns, above, below, N, S; N := LinearAlgebra[ColumnDimension](returns); S := LinearAlgebra[RowDimension](returns); weightedReturns := [seq(add(returns[i, j]*weights[j], j = 1 .. N), i = 1 .. S)]; below := select(proc (x) options operator, arrow; evalb(x < L) end proc, weightedReturns); above := select(proc (x) options operator, arrow; evalb(L < x) end proc, weightedReturns); return add(a-L, `in`(a, above))/add(L-a, `in`(a, below)) end proc

 

"Strawman" portfolio of equal weights at the target return

OmegaRatio(L, data, [.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])

HFloat(4.003192510007608)

(2.3)

Global Optimization

 

resultsGO := GlobalOptimization[GlobalSolve](('OmegaRatio')(L, data, [seq(w[i], i = 1 .. 10)]), {add(w[i], i = 1 .. N) = 1}, seq(w[i] = 0 .. 1, i = 1 .. N), maximize)

 

Optimized Omega Ratio

resultsGO[1]

6.97847546127661378

(2.2.1)

Optimized investment weights

weightsGO := resultsGO[2]

[w[1] = HFloat(0.0), w[2] = HFloat(0.0), w[3] = HFloat(0.0), w[4] = HFloat(0.4089744892232919), w[5] = HFloat(0.0), w[6] = HFloat(0.2202055421596614), w[7] = HFloat(0.331780058735942), w[8] = HFloat(0.0), w[9] = HFloat(0.0), w[10] = HFloat(0.0390399098810971)]

(2.2.2)

Linear Program

 

The transformation of the optimization problem into a linear program is described here

eq1 := seq(add(data[i, j]*w[j], j = 1 .. N)-u[i]+d[i]-L*t = 0, i = 1 .. S)

eq2 := add(w[j], j = 1 .. N) = t

eq3 := add(d[i]/S, i = 1 .. S) = 1

obj := add(u[i]/S, i = 1 .. S)

cons := seq([u[i] >= 0, d[i] >= 0][], i = 1 .. S), seq([w[j] >= 0][], j = 1 .. N)

resultsLP := Optimization[LPSolve](obj, {cons, eq1, eq2, eq3}, maximize, assume = nonnegative)


Optimized Omega Ratio

resultsLP[1]

6.97971754550025

(2.3.1)

Optimized investment weights

assign(select(has, resultsLP[2], t))

weightsLP := map(proc (i) options operator, arrow; lhs(i) = rhs(i)/t end proc, select(has, resultsLP[2], w))

[w[1] = HFloat(0.0), w[2] = HFloat(0.0), w[3] = HFloat(0.0), w[4] = HFloat(0.40979022216167177), w[5] = HFloat(0.0), w[6] = HFloat(0.21961738132814781), w[7] = HFloat(0.33321118343926637), w[8] = HFloat(0.0), w[9] = HFloat(0.0), w[10] = HFloat(0.037381213348692446)]

(2.3.2)