Running max

Hook

The worst ride along the way

Your fund returned 40% over five years. Investors are pleased, then they ask a harder question: what was the worst peak-to-trough loss along the way? A fund that fell by half before recovering is a very different ride from one that never fell more than a tenth. This lesson finds that number with a single loop.

Concept

Carrying state through a loop

A for loop looks at one item at a time. To answer a question about the whole list, you keep a variable outside the loop and update it inside it. That variable carries what you have learned so far from one step to the next.

The most useful example is the running maximum: the highest value seen so far.

prices = [100, 104, 101, 108, 103]
peak = prices[0]
for price in prices:
    if price > peak:
        peak = price
    print(price, peak)

peak starts at the first price. On each step it either stays the same or moves up to a new high, and it never moves down. When the loop ends, peak holds the highest price in the list.

Worked example

Recording the peak every day

A risk chart needs the running peak for every day, not only at the end. Add each day’s peak to a new list:

prices = [100, 104, 101, 108, 103]
peaks = []
peak = prices[0]
for price in prices:
    if price > peak:
        peak = price
    peaks.append(peak)
print(peaks)

It prints [100, 104, 104, 108, 108]. On day three the price dips to 101, but the peak stays at 104: the dip is a drawdown from that peak. The problem below measures exactly those dips.

Check

Predict the output

Problem

Maximum drawdown

max_drawdown(prices) -> float

A drawdown is how far a price has fallen from its highest point so far, as a fraction of that high. If LABX climbs to 120 and then falls to 90, the drawdown at 90 is (120 − 90) / 120 = 0.25, a 25% fall.

The maximum drawdown is the largest drawdown over the whole series: the worst peak-to-trough loss an investor would have lived through.

Fill in max_drawdown(prices). It receives a list of daily closing prices, oldest first, and returns the maximum drawdown as a fraction between 0 and 1.

A longer example, a month of LABX, with the running peak and the drawdown shaded:

Constraints: prices holds between 1 and 100,000 positive numbers. Your function should look at each price once: the tests time it on long series.

Solve it in the editor

Hints

Stuck? Open one hint at a time

peak = first price
worst = 0
for each price:
    if price is above peak: peak = price
    drawdown = (peak - price) / peak
    if drawdown is above worst: worst = drawdown
return worst

Solution

How to solve it

def max_drawdown(prices):
    peak = prices[0]
    worst = 0.0
    for price in prices:
        if price > peak:
            peak = price
        drawdown = (peak - price) / peak
        if drawdown > worst:
            worst = drawdown
    return worst

def max_drawdown(prices):
    worst = 0.0
    for i in range(len(prices)):
        peak = max(prices[: i + 1])
        worst = max(worst, (peak - prices[i]) / peak)
    return worst

import numpy as np

def max_drawdown(prices):
    prices = np.asarray(prices, dtype=float)
    return float((1 - prices / np.maximum.accumulate(prices)).max())