Return Calculation

Return calculation converts raw stock prices into percentage changes for analysis. Event studies use two methods: simple returns (percentage price change) and log returns (natural logarithm of price ratio). Simple returns are the default because they are intuitive and cross-sectionally additive.

Event studies measure abnormal returns — the difference between actual and expected returns. Before fitting any model, raw prices must be converted to returns. The EventStudy R package supports two methods: simple returns and log returns.

What Are Simple and Log Returns?

Return calculation is the process of transforming raw asset prices into standardized percentage changes that serve as the input for expected return models and abnormal return estimation. The choice between simple and log returns affects time-series aggregation, distributional properties, and cross-sectional additivity. For typical daily stock returns averaging 0.04% with a standard deviation of approximately 1.5%, the two methods yield nearly identical values, diverging only for large price moves exceeding 5%.

Simple Return

The percentage change in price between two consecutive periods. Simple returns are cross-sectionally additive, meaning portfolio returns equal the weighted sum of individual asset returns.

Log Return

The natural logarithm of the price ratio between consecutive periods. Log returns are time-additive, meaning the cumulative return over multiple periods equals the sum of individual-period log returns.

Simple Returns

Simple returns represent the percentage change in price. They are intuitive and directly interpretable: a return of 0.05 means a 5% gain. Over 80% of published event studies use simple returns as the default calculation method.

# Demonstrate simple return calculation
prices <- c(100, 105, 102, 108)
simple_returns <- diff(prices) / head(prices, -1)
tibble(
  t = 1:3,
  price_t_minus_1 = head(prices, -1),
  price_t = tail(prices, -1),
  simple_return = round(simple_returns, 4)
)

Key property: Simple returns are cross-sectionally additive — a portfolio's return is the weighted sum of its constituents' returns. This makes them natural for cross-sectional aggregation (AAR, CAAR).

Limitation: They are not time-additive. The cumulative return over multiple periods requires compounding:

Log Returns

Log returns (continuously compounded returns) are the natural logarithm of the price ratio.

# Demonstrate log return calculation
prices <- c(100, 105, 102, 108)
simple_returns <- diff(prices) / head(prices, -1)
log_returns <- diff(log(prices))
tibble(
  t = 1:3,
  price_t_minus_1 = head(prices, -1),
  price_t = tail(prices, -1),
  log_return = round(log_returns, 4),
  simple_return = round(simple_returns, 4)
)

Key property: Log returns are time-additive — the cumulative return is simply the sum:

Limitation: They are not cross-sectionally additive — a portfolio's log return is not the weighted sum of constituent log returns.

How Do Simple and Log Returns Compare?

For small returns (under ~5%), simple and log returns are nearly identical. They diverge for large price moves. As demonstrated by Hudson and Gregoriou (2010) using 112 years of Dow Jones data from 1897 to 2009, the difference is negligible for typical daily stock returns (< 3%): a 2% simple return corresponds to a 1.98% log return, a gap of only 0.02 percentage points. For extreme events (crashes, M&A premiums with returns of 20% or more), the choice matters more — a 50% simple return corresponds to only a 40.5% log return.

How Do I Set the Return Type in R?

The ParameterSet controls which return calculation is used. The default is SimpleReturn:

# Default: simple returns
ps_simple <- ParameterSet$new(
  return_calculation = SimpleReturn$new()
)

# Alternative: log returns
ps_log <- ParameterSet$new(
  return_calculation = LogReturn$new()
)

Run the same event study with each:

task_simple <- EventStudyTask$new(firm_data, index_data, request)
task_simple <- run_event_study(task_simple, ps_simple)

task_log <- EventStudyTask$new(firm_data, index_data, request)
task_log <- run_event_study(task_log, ps_log)

# Compare CAAR under both return types
caar_simple <- tidy.EventStudyTask(task_simple, type = "aar") %>%
  mutate(event_time = as.numeric(term), type = "Simple Return")
caar_log <- tidy.EventStudyTask(task_log, type = "aar") %>%
  mutate(event_time = as.numeric(term), type = "Log Return")
caar_both <- bind_rows(caar_simple, caar_log)

For typical daily event studies, the curves are nearly identical.

Which Return Type Should I Use?

Use log returns when:

• You need time-additive cumulative returns (e.g., for BHAR long-horizon studies)
• Your model assumes normally distributed returns (log returns are closer to normal for daily data)
• You are working with high-frequency data where compounding over many intervals matters

Literature

• Hudson, R. & Gregoriou, A. (2010). Calculating and Comparing Security Returns is Harder than you Think. An empirical comparison using the Dow Jones Index 1897–2009 showing that mean returns differ significantly between methods, especially after large price changes.
• Campbell, J.Y., Lo, A.W. & MacKinlay, A.C. (1997). The Econometrics of Financial Markets. Chapter 4 covers return calculation in the context of event studies.
• Kolari, J.W. & Pynnonen, S. (2010). Event Studies for Financial Research. Practical guidance on return methodology choices.

What Should I Read Next?

• Expected Return Models — choose between 15 models for estimating normal returns
• Getting Started — quick start guide with R code
• Diagnostics — validate your model fit