1.4.7 Case study: simple returns and log returns

Two ways to measure a return

For a price that moves from $P_{t-1}$ to $P_t$ over one period:

\begin{gathered} \text{simple return } R_t = \frac{P_t}{P_{t-1}} - 1 \\[6pt] \text{log return } r_t = \ln\frac{P_t}{P_{t-1}} = \ln(1 + R_t) \end{gathered}

The ratio $P_t / P_{t-1} = 1 + R_t$ is the gross return: what each dollar became. Both returns summarise it, in two different ways.

A return has no units, but it always belongs to a period: a day, a month, a year. Both are decimals in formulas, so 0.05 is 5%.

Try it Here is the stock from the opening: 100, then 150, then 75. The average simple return says 0%, but the total return is -25%. Simple returns do not add up across time.

import numpy as np prices = np.array([100.0, 150.0, 75.0]) simple = prices[1:] / prices[:-1] - 1 logret = np.log(prices[1:] / prices[:-1]) print("simple:", simple) print("log: ", logret) print("average simple return:", simple.mean()) print("total simple return: ", prices[-1] / prices[0] - 1)

⌘/Ctrl + Enter runs the cell

The two side by side

Plot the log return against the simple return and three facts appear.

The log return against the simple return. They agree near 0, the log return is always the smaller, and it plunges as $R$ nears $-100\%$ . A doubling and a halving have log returns of equal size and opposite sign.

Near 0 they agree. Daily returns are usually well under 1%, so the two are almost identical from day to day.
The log return is always the smaller. $\ln(1 + R) \le R$ , with equality only at $R = 0$ . The gap grows with the size of the move.
Log returns are symmetric. Doubling gives $\ln 2 \approx 0.6931$ and halving gives $\ln 0.5 \approx -0.6931$ , so a move and its undoing cancel. In simple returns the same pair reads $+100\%$ and $-50\%$ .

A total loss, $R = -100\%$ , has no log return at all: $\ln 0$ does not exist (lesson 1.4.3). Near it, the log return heads to minus infinity.

\ln(1 + R) \approx R - R^2/2

import numpy as np for R in [0.001, 0.01, 0.05, 0.10, 0.20, 0.50, -0.20, -0.50]: print(f"R = {R:+.3f} ln(1+R) = {np.log1p(R):+.5f} R - R^2/2 = {R - R**2 / 2:+.5f}")

⌘/Ctrl + Enter runs the cell

Log returns add across time

Take a stock that goes from 100 to 110, then to 99. The two log returns are $\ln 1.1$ and $\ln 0.9$ . Their sum is the log return over the whole span:

\begin{aligned} \ln 1.1 + \ln 0.9 &= \ln(1.1 \times 0.9) \\ &= \ln 0.99 = \ln\frac{99}{100} \end{aligned}

That is the product rule of logs. It works for any number of periods, because the gross returns multiply and the middle prices cancel:

\begin{gathered} \frac{P_T}{P_0} = \frac{P_1}{P_0}\cdot\frac{P_2}{P_1}\cdots\frac{P_T}{P_{T-1}} \\[6pt] \text{so}\quad r_{0\to T} = r_1 + r_2 + \cdots + r_T \end{gathered}

1 + R_{0\to T} = (1+R_1)(1+R_2)\cdots(1+R_T)

import numpy as np path = np.array([100.0, 110.0, 99.0]) r = np.log(path[1:] / path[:-1]) print("one-period log returns:", r) print("their sum: ", r.sum()) print("log of total: ", np.log(path[-1] / path[0]))

⌘/Ctrl + Enter runs the cell

Check yourself

A stock goes from 100 to 110, then to 99. Which statement is true?

The total simple return is 0%, because +10% and −10% cancelThe total log return is

\ln 1.1 + \ln 0.9 = \ln 0.99

The total log return is 0

Average and annual returns

The hook's 0% is the arithmetic mean of the simple returns, and it overstates growth. The honest average is the steady return per period that gives the same total: the geometric mean.

\begin{gathered} \left(\frac{P_T}{P_0}\right)^{1/T} - 1 \\ = e^{\bar r} - 1 \end{gathered}

Here $T$ is the number of periods and $\bar r$ is the mean of the log returns. For the hook, $\sqrt{1.5 \times 0.5} - 1 \approx -13.40\%$ a month: two months at that rate also lose 25%.

Annualising

Log returns scale with time because they add. Over 252 trading days, the usual count for daily stock data, a mean daily log return of 0.0004 becomes 0.1008 for the year. As a simple return that is $e^{0.1008} - 1 \approx 10.61\%$ .

Simple returns compound instead. The same daily return is $e^{0.0004} - 1 \approx 0.040008\%$ as a simple return, and $(1.00040008)^{252} - 1$ gives the same 10.61%. Multiplying it by 252 gives about 10.08%, which is wrong.

Try it The cell computes the hook's geometric mean two ways, then annualises the daily return.

import math import numpy as np prices = np.array([100.0, 150.0, 75.0]) logret = np.log(prices[1:] / prices[:-1]) T = len(logret) print("geometric from prices:", (prices[-1] / prices[0]) ** (1 / T) - 1) print("geometric from logs: ", np.exp(logret.mean()) - 1) mu = 0.0004 daily = math.exp(mu) - 1 print("annual log return:", round(mu * 252, 6)) print("annual simple: ", round(math.exp(mu * 252) - 1, 6)) print("compounded daily: ", round((1 + daily) ** 252 - 1, 6)) print("daily times 252: ", round(daily * 252, 6))

⌘/Ctrl + Enter runs the cell

Check yourself

A fund's monthly log returns over a year average 0.01. What is its simple return for the year?

12% exactly

e^{0.12} - 1 \approx 12.75\%

1.01^{12} - 1 \approx 12.68\%

Simple returns add across assets

A portfolio's weights are the fractions of its starting value in each asset. They add up to 1. Each asset contributes its weight times its own return:

Rule: Portfolio return

\begin{gathered} R_p = \sum_i w_i R_i \\ = w_1 R_1 + w_2 R_2 + \cdots + w_n R_n \end{gathered}

This works for simple returns only. The log of a weighted sum is not the weighted sum of logs. So portfolio and risk totals, such as value at risk across desks, are built from simple returns.

0.6 \times 0.10 + 0.4 \times (-0.05)

import numpy as np weights = np.array([0.6, 0.4]) returns = np.array([0.10, -0.05]) start = 10_000 * weights end = start * (1 + returns) print("values at the end:", end, "total:", end.sum()) print("portfolio return from values: ", end.sum() / 10_000 - 1) print("portfolio return from weights:", weights @ returns)

⌘/Ctrl + Enter runs the cell

The weighted sum of log returns can be badly wrong. Split money equally between assets returning +30% and −20%. The portfolio's simple return is 5%, so its log return is $\ln 1.05 \approx 0.0488$ . The weighted sum of the two log returns is only 0.0196.

Check yourself

A portfolio is 70% in an asset that returns +8% and 30% in an asset that returns −2%. What is the portfolio's simple return?

3%6%5%You need log returns to answer

Across assets and over time together

A desk report needs both at once: a portfolio's return over many periods. The recipe is to work across assets with simple returns in each period, then across time with log returns.

Keep the $10,000 portfolio for a second period, in which the stock returns −8% and the bond +3%. Nobody trades, so the weights drift: after period 1 the stock is $6,600 of $10,400, a weight of 63.46%, not 60%.

Period 1: $R_{p,1} = 4\%$ , and the portfolio is worth $10,400.
Period 2, with the drifted weights: $R_{p,2} \approx -3.9808\%$ , and the portfolio is worth $9,986.
Over both: $\ln 1.04 + \ln(1 - 0.039808) = \ln 0.9986$ , a total return of $-0.14\%$ .

Using 60% and 40% again in period 2 would give $-3.60\%$ . That is right only if someone rebalances back to 60/40 at the start of period 2.

Try it The loop recomputes the weights from the current values at the start of each period, then grows each holding by its return. The second line ends with 9986.0, the value after both periods. The last line adds the two log returns; they match the log of the total growth.

import numpy as np value = 10_000 * np.array([0.6, 0.4]) log_total = 0.0 for R in [np.array([0.10, -0.05]), np.array([-0.08, 0.03])]: weights = value / value.sum() rp = weights @ R log_total += np.log1p(rp) value = value * (1 + R) print(np.round(weights, 4), round(rp, 6), value.sum()) print("total log return:", log_total, "=", np.log(value.sum() / 10_000))

⌘/Ctrl + Enter runs the cell

Why up and down loses money

A rise of $x$ followed by a fall of $x$ multiplies your money by $(1 + x)(1 - x) = 1 - x^2$ . That is always less than 1, so you always end up poorer. The loss is $x^2$ : 25% for a 50% swing, but only 0.01% for a 1% swing.

-\tfrac{1}{2}\sigma^2

⌘/Ctrl + Enter runs the cell

Bad inputs on a desk

Real price files break both formulas in predictable ways. Check for each of these before computing a single return.

A price of 0. After a default the simple return is $-100\%$ and the log return is minus infinity. NumPy prints -inf.
A negative price. Some futures and price spreads can trade below zero. Then $P_t / P_{t-1}$ can be negative, the log return does not exist, and desks track price changes in dollars instead.
Splits and dividends. A 2-for-1 split halves the price without anyone losing money. On raw prices it looks like a return of $-50\%$ , a log return of $-0.6931$ . Use prices adjusted for splits and dividends.
Missing prices. One missing price spoils the two returns on either side of it, and every sum that includes them.

Try it The first line shows a fall to 0 and to a negative price: -inf and nan, for "not a number". np.errstate hides the warnings NumPy would print; on a desk you would want to see them. The second line shows one missing price, written np.nan, spoiling two returns.

import numpy as np with np.errstate(divide="ignore", invalid="ignore"): print(np.log(np.array([0.0, -10.0]) / 50.0)) prices = np.array([100.0, np.nan, 102.0]) print(np.log(prices[1:] / prices[:-1]))

⌘/Ctrl + Enter runs the cell

Exercise

Returns from prices

Write three functions. Each takes a NumPy array of prices in time order.

simple_returns(prices) returns the array of one-period simple returns.
log_returns(prices) returns the array of one-period log returns.
total_log_return(prices) returns the log return from the first price to the last, as a single number.

Both arrays should be one element shorter than prices. NumPy slicing (prices[1:], prices[:-1]) avoids any loop.

See the tests

import numpy as np

PRICES = np.array([100.0, 110.0, 99.0, 105.0])


def test_simple_returns():
    """Simple returns of 100, 110, 99, 105"""
    expect_close(simple_returns(PRICES), [0.10, -0.10, 105 / 99 - 1], what="simple_returns")


def test_log_returns():
    """Log returns of 100, 110, 99, 105"""
    expect_close(log_returns(PRICES), np.log([1.10, 0.90, 105 / 99]), what="log_returns")


def test_lengths():
    """Both arrays are one shorter than the prices"""
    expect_equal(len(simple_returns(PRICES)), 3, what="len(simple_returns)")
    expect_equal(len(log_returns(PRICES)), 3, what="len(log_returns)")


def test_total_is_sum_of_logs():
    """The total log return equals the sum of the one-period log returns"""
    expect_close(total_log_return(PRICES), float(np.sum(log_returns(PRICES))), what="total_log_return vs sum")
    expect_close(total_log_return(PRICES), np.log(1.05), what="total_log_return(100 to 105)")


def test_random_prices():
    """Works on a long random price path"""
    rng = np.random.default_rng(7)
    path = 50 * np.exp(np.cumsum(rng.normal(0, 0.01, 500)))
    expect_close(np.exp(np.sum(log_returns(path))), path[-1] / path[0], what="exp(sum of log returns)")
    expect_close(np.prod(1 + simple_returns(path)), path[-1] / path[0], what="product of gross returns")

Exercise

A portfolio's return

Write portfolio_return(weights, returns) returning the portfolio's simple return, given NumPy arrays of weights and of the assets' simple returns.

Then write portfolio_log_return(weights, returns) returning the portfolio's log return. Careful: it is not the weighted sum of the assets' log returns. Work out the simple return first, then convert.

See the tests

import numpy as np


def test_sixty_forty():
    """60% at +10% and 40% at -5% returns 4%"""
    expect_close(portfolio_return(np.array([0.6, 0.4]), np.array([0.10, -0.05])), 0.04, what="portfolio_return")


def test_three_assets():
    """Three assets with weights 0.5, 0.3, 0.2"""
    w = np.array([0.5, 0.3, 0.2])
    r = np.array([0.02, -0.01, 0.05])
    expect_close(portfolio_return(w, r), 0.5 * 0.02 - 0.3 * 0.01 + 0.2 * 0.05, what="portfolio_return")


def test_log_return_converts_at_the_end():
    """The portfolio log return is ln(1 + portfolio simple return)"""
    w = np.array([0.6, 0.4])
    r = np.array([0.10, -0.05])
    expect_close(portfolio_log_return(w, r), np.log(1.04), what="portfolio_log_return")


def test_log_return_is_not_weighted_logs():
    """It differs from the weighted sum of log returns"""
    w = np.array([0.5, 0.5])
    r = np.array([0.30, -0.20])
    wrong = float(np.dot(w, np.log1p(r)))
    got = portfolio_log_return(w, r)
    assert got is not None and abs(got - wrong) > 1e-3, (
        f"got {got}, which matches the weighted sum of log returns ({wrong:.6f}); convert the portfolio simple return instead"
    )

R_t = P_t/P_{t-1} - 1

Case study: simple returns and log returns

Two ways to measure a return

The two side by side

Log returns add across time

Average and annual returns

Annualising

Simple returns add across assets

Rule: Portfolio return

Across assets and over time together

Why up and down loses money

Bad inputs on a desk

Returns from prices

A portfolio's return

Summary card

Free further reading