Log returns

The logarithm of the price ratio

A log return is the natural logarithm of the ratio between two prices. Instead of P_t / P_{t-1} - 1 you compute ln(P_t / P_{t-1}). For small moves the two are almost equal (a 2% rise is 0.0198 in logs), but the log version has properties that make it the standard choice for statistics and modelling. In pandas, take the logarithm of the whole price Series with np.log and then diff it: subtracting logs is dividing prices.

import numpy as np
import pandas as pd

prices = pd.Series([100.0, 102.0, 100.98, 103.0], index=["Mon", "Tue", "Wed", "Thu"])

log_ret = np.log(prices).diff()
print(log_ret.round(4))
# Mon       NaN
# Tue    0.0198
# Wed   -0.0101
# Thu    0.0198
# dtype: float64

print(prices.pct_change().round(4).tolist())   # [nan, 0.02, -0.01, 0.02]   the simple returns, for comparison

Log returns add up over time

This is the main reason to use them. Because ln(a) - ln(c) = (ln(a) - ln(b)) + (ln(b) - ln(c)), the log return over several periods is just the sum of the period log returns, with no compounding. The two-day return is the sum of two daily ones, the monthly return is the sum of the daily ones, and exp(total) - 1 turns the result back into a simple return. Log returns are also symmetric: a price that doubles and then halves has log returns of +0.6931 and -0.6931, which cancel, whereas the simple returns were +100% and -50%.

# The sum of the daily log returns is the log return over the whole period
print(round(log_ret.sum(), 6))                         # 0.029559
print(round(np.log(prices.iloc[-1] / prices.iloc[0]), 6))   # 0.029559   end price over start price

# exp(total) - 1 is the simple return of the whole period
print(round(np.exp(log_ret.sum()) - 1, 6))             # 0.03

# Symmetry: the price doubles, then halves
doubling = pd.Series([100.0, 200.0, 100.0])
print(doubling.pct_change().tolist())               # [nan, 1.0, -0.5]
print(np.log(doubling).diff().round(4).tolist())    # [nan, 0.6931, -0.6931]

Converting, and moves over several days

To go back to a simple return use np.exp(r) - 1 (or np.expm1(r), which is more precise for tiny values). The two agree closely for small moves and drift apart for big ones: a +50% simple return is 0.4055 in logs. np.log and np.exp work on a whole Series, so there is no loop. To measure a move over several days, diff takes the number of periods: np.log(prices).diff(5) is the log return over five days, and it equals the sum of five daily log returns.

# Small moves agree with the simple return, big moves do not
for simple in [0.01, 0.1, 0.5, -0.5]:
    print(simple, round(np.log1p(simple), 4))   # log1p(r) is ln(1 + r)
# 0.01 0.01
# 0.1 0.0953
# 0.5 0.4055
# -0.5 -0.6931

# Back to simple returns, on the whole Series at once
print((np.exp(log_ret) - 1).round(4).tolist())   # [nan, 0.02, -0.01, 0.02]

# The log return over 2 days: diff takes a number of periods
print(np.log(prices).diff(2).round(4).tolist())   # [nan, nan, 0.0098, 0.0098]

• A log return is ln(price / previous price): np.log(prices).diff(); the first entry is NaN.
• Over time they simply add: log_ret.sum(), and np.exp(total) - 1 gives the simple return.
• diff(k) gives the move over k periods; across assets, weight the simple returns, not the log ones.

Next up: DatetimeIndex and time-based indexing, giving a price series real dates so you can slice by month or weekday.

Lab · what's graded

• Turn prices into log returns with log_returns25 pts
• Convert log returns back to simple returns with simple_from_log25 pts
• Add up the period log returns with total_log_return25 pts
• Measure the move over several days with multi_day_log_return25 pts