Fri 28 Sep 2007

## Calculating peak-to-trough drawdown

Posted by Steve Knight under article, finance, programming, python

[12] Comments

Ok, so this is a little bit technical but it’s an intriguing puzzle that got me thinking quite hard. So here’s the problem. Sometimes investors want to be able to judge what the absolute worst case scenario would have been if they’d invested in something. Look at the following random graph of pretend asset prices:

You’ll see that there are two points on the graph (marked in red) where if you had invested at the first point and pulled out on the second point you would have the worst-case loss. This is the point of this analysis and is a way for investors in the asset to see how bad, ‘bad’ has really been in the past. Clearly past prices are not an indicator of future losses.

The upper one is the ‘peak’ and the lower one is the ‘trough’. Well, finding these two babys by eye is trivial. To do it reliably (and quickly) on a computer, is not that straight forward. Part of the problem is coming up with a consistent natural language of what you want your peak and trough to be. This took me some time. I believe what I really want is: the largest positive difference of high minus low where the low occurs after the high in time-order. This was the best I could do. This led to the first solution (in Python):

```
def drawdown(prices):
maxi = 0
mini = 0
for i in range(len(prices))[1:]:
maxj = 0
max = 0
for j in range(i+1, len(prices)):
if prices[i] - prices[j] > max:
maxj = j
max = prices[i] - prices[j]
if max > prices[maxi] - prices[mini]:
maxi = i
mini = maxj
return (prices[maxi], navs[mini])
```

Now this solution is easy to explain. It’s what I have come to know as a ‘between’ analysis. I don’t know if that’s the proper term but it harks back to the days when I used to be a number-cruncher for some statisticians. The deal is relatively straight-forward: compare the fist item against every item after it in the list and store the largest positive difference. If this difference is also the largest seen in the data-set so far then make it the largest positive difference of all points. At the end you just return the two points you found. This is a natural way to solve the problem because it looks at all possible start points and assesses what the worst outcome would be.

The problem with this solution is that it has quadratic complexity. That is for any data-series of size N the best and worst case will result in N * N-1 iterations, in shorthand this is O(N^2). For small n this doesn’t really matter, but for any decently sized data-series this baby will be slow-as-molasses. The challenge then is to find an O(N) solution to the problem and to save-those-much-needed-cycles for something really important:

```
def drawdown(prices):
prevmaxi = 0
prevmini = 0
maxi = 0
for i in range(len(prices))[1:]:
if prices[i] >= prices[maxi]:
maxi = i
else:
# You can only determine the largest drawdown on a downward price!
if (prices[maxi] - prices[i]) > (prices[prevmaxi] - prices[prevmini]):
prevmaxi = maxi
prevmini = i
return (prices[prevmaxi], prices[prevmini])
```

This solution is a bit harder to explain. We move through the prices and the first part of the ‘if’ will find the highest part of the peak so far. However, the second part of the ‘if’ is where the magic happens. If the next value is less than the maximum then we see if this difference is larger than any previously encountered difference, if it is then this is our new peak-to-trough.

The purist in me likes that fact that the O(N) solution looks like easier code to understand than the O(N^2) solution. Although the O(N^2) solution is, I think, an easier concept to grapple with, when it’s translated into code it just doesn’t grok.