The Average Daily Range is a technical indicator used to measure volatility in an asset. It calculates the average difference between the highest and lowest price over a time interval. Typically, this indicator is used to signal a significant change in price action over the short term.

**Table of Contents**show

## Introduction

The Average Daily Range (ADR) is similar to a moving average in that it reflects the average of previous values. This helps smooth out noise and reflects a better representation of an asset over time. In this guide we’ll cover the following:

- How to calculate the ADR generally
- How to implement an ADR function in Python
- How to apply an ADR function to a DataFrame object in Python
- The downsides of the ADR
- Implementing a modified ADR
- Average Daily Range vs. Average True Range

The ADR can be a great tool in identifying stocks or tradable assets that are currently experiencing high levels of volatility. This can signal an increase in volume, response to events like news, or abrupt changes in price action. Before we dive in, let’s first talk a bit more about what the ADR is conceptually and how it’s used.

## What’s the ADR

The ADR is a measure of volatility and is useful to describe whether an assets price action is outside the normal during a particular time. The **daily range** (highest price – lowest) can be compared to the ADR over a previous interval to signal potential entry and exit points for traders.

The ADR can be used over whatever interval one chooses, though a 20-day period is common. In stock market technical analysis, this period uses the previous 19 values—along with the current value—to calculate an averaged number for the daily trading range. This can help signal abrupt changes in price action and is useful in stock screeners.

## Calculating the ADR

The Average Daily Range is calculated similarly to how one calculates a simple moving average. **The difference between the Average Daily Range and a simple moving average is that we must pre-calculate the difference between the high and low for each period**. After these values are calculated one can calculate the ADR. The average daily range formula is as follows:

Equations can be a bit heady and often confuse otherwise simple calculations. An iterative approach to calculating the ADR is outlined as such:

- Define a “
*lookback*” interval (K) - For each period, calculate
*Daily Range*(DR) as:*High*–*Low*to get the Daily Range (H_{xi}– L_{xi})

- Sum all
*Daily Range*values - Divide by the
*lookback*interval length

Let’s consider an illustration of the above. First, anyone unfamiliar with candlestick representation of stock prices should check out this article. In the illustration below we can see the Daily Range calculated for each period over a 5-day interval (K) and then added together and divided by K. This gives us the ADR for that period.

This image depicts a stock price that is gradually becoming more volatile over a 5-day period. The first period has a Daily Range of 2 while the last two periods have a daily range of 4. The average daily range here is 3.2 —accounting for the daily range of each period.

## Calculating the Average Daily Range in Python

We’ve now seen the mathematical basis for calculating the ADR. Modern trading doesn’t rely on pencil and paper, however. To deploy the ADR as an analytical tool we will implement our logic so far as a Python function. First, let’s create a representation of the price action shown in the image above.

# Five prices as High and Low for the # five day period K prices = [ {"high": 5, "low": 3}, {"high": 7, "low": 4}, {"high": 9, "low": 6}, {"high": 7, "low": 3}, {"high": 8, "low": 4}, ] # Example access day_one_high = prices[0]["high"] day_one_low = prices[0]["low"]

In practice, it would be practical to have this type of data stored as OHLCV in a pandas DataFrame object. We’re using a list of 5 dictionary objects here for syntactic clarity. Keeping in mind our algorithm outlined above, we can implement the ADR in Python as follows:

# Create list for Daily Range values daily_ranges = [] # Get High - Low (DR) for each period for price in prices: # Calculate DR pct_daily_range = price["low"] / price["high"] # Normalize daily_ranges.append(100 * (pct_daily_range - 1)) # Calculate Average Daily Range average_daily_range = sum(daily_ranges) / len(daily_ranges) # View output print(average_daily_range) >>> 3.2

Here we see our result matches up to the manual calculation from the illustrated process above. The example code above is a bit bloated—mostly for sake of clarity—so we’ll tighten things up a bit before we start looking at more practical examples:

# calculate ADR from list of (high, low) tuples sum([x[0] - x[1] for x in prices]) / len(prices)

This one-liner will make calculating the ADR for some real-world data a bit less syntactically cumbersome. To showcase the utility of the ADR we will fetch the latest stock pricing data and use the resulting `DataFrame`

object for our ADR calculations.

## ADR Example

We are going to use the `yfinance`

library to fetch pricing data for Ether (`$ETH-USD`

) over the past 6 months. We can get this data with the following code:

# Get pricing data import yfinance as yf # Get the previous 6 months pricing data for ETH and limit to High, Low ETH = yf.Ticker('ETH-USD').history(period='6mo', interval="1d")[["High", "Low"]] # View resulting dataframe print(ETH) High Low Date 2021-05-18 3562.465088 3246.404053 2021-05-19 3437.935791 1952.460205 2021-05-20 2993.145264 2170.229004 2021-05-21 2938.205078 2113.347168 2021-05-22 2483.983154 2168.124268 ... ... ... 2021-11-14 4689.842773 4516.935547 2021-11-15 4764.636230 4546.599121 2021-11-16 4891.704590 4144.334961 2021-11-17 4300.306641 4107.125977 2021-11-18 4343.557129 4138.691406 [185 rows x 2 columns]

Here we have queried the Yahoo Finance API (sort of) and retrieved the previous 6-months pricing data for `$ETH-USD`

and removed all data but the High and Low value for each day, while also keeping the date as the index values.

### Step 1: Calculate Daily Range Values

For each period in our interval, we need to calculate the daily range from the High – Low calculation. This is done using the apply method of the DataFrame object as such:

# Calculate Daily Range for each period ETH['dr'] = ETH.apply(lambda x: x["High"] - x["Low"], axis=1) # Result High Low dr Date 2021-05-18 3562.465088 3246.404053 316.061035 2021-05-19 3437.935791 1952.460205 1485.475586 2021-05-20 2993.145264 2170.229004 822.916260 2021-05-21 2938.205078 2113.347168 824.857910 2021-05-22 2483.983154 2168.124268 315.858887 ... ... ... ... 2021-11-14 4689.842773 4516.935547 172.907227 2021-11-15 4764.636230 4546.599121 218.037109 2021-11-16 4891.704590 4144.334961 747.369629 2021-11-17 4300.306641 4107.125977 193.180664 2021-11-18 4343.557129 4052.962158 290.594971 [185 rows x 3 columns]

We now have a third column reflecting the difference in our daily High and daily Low. Next, we need to calculate the average of these values over a preceding period. To do this—effectively calculating a moving average—we will use the rolling method of the DataFrame.

### Step 2: Calculate Average Daily Range

Before we calculate the Average Daily Range we need to define our lookback period. A common value for this is 20 periods and what we will use here. This decision means that every ADR value we calculate is reflective of the previous 19 periods of price action plus the range of the current period. This can be achieved via the following code:

# Add a simple moving average ETH["adr"] = ETH['dr'].rolling(window=20).mean() # View result High Low dr adr Date 2021-05-18 3562.465088 3246.404053 316.061035 NaN 2021-05-19 3437.935791 1952.460205 1485.475586 NaN 2021-05-20 2993.145264 2170.229004 822.916260 NaN 2021-05-21 2938.205078 2113.347168 824.857910 NaN 2021-05-22 2483.983154 2168.124268 315.858887 NaN ... ... ... ... ... 2021-11-14 4689.842773 4516.935547 172.907227 217.784058 2021-11-15 4764.636230 4546.599121 218.037109 219.570532 2021-11-16 4891.704590 4144.334961 747.369629 238.494238 2021-11-17 4300.306641 4107.125977 193.180664 228.781030 2021-11-18 4343.557129 4052.962158 290.594971 234.109387 [185 rows x 4 columns]

A few things to note: first, we see a new column has been added for the ADR. Secondly—and most important—we see a value of `NaN`

for the first entries. This is because there are fewer than 10 (20 – 1) preceding values for these dates.

**We need a minimum of 20 values to calculate the ADR since that is how we defined our lookback window**. For example, if we were to print out rows 18-22 we can see where the transition takes place:

# Print rows # 18-21 print(ETH.iloc[17:21]) High Low dr adr Date 2021-06-04 2857.165527 2562.637451 294.528076 NaN 2021-06-05 2817.484863 2558.233643 259.251221 NaN 2021-06-06 2743.441162 2616.162354 127.278809 435.919141 2021-06-07 2845.185059 2583.995117 261.189941 433.175586

In row `#20`

for the date `2021-06-06`

, we have our first DR value where there are enough preceding values to calculate the average using our 20-period lookback window.

## Modified ADR

The ADR is a great measure of volatility and can help signal a great opportunity to traders and investors. However, it has the shortcoming of being very specific to the price action of a single stock. For example, the ADR of `$ETH-USD`

during the past several days has been around $220USD.

What happens when we try to compare `$ETH-USD`

‘s ADR to an asset whose price is between $5USD and $10USD? It’s certainly not going to be taking $220 swings! However, the *percent change* in price would still be comparable.

To use the ADR as a screening tool, such that one can compare volatility among different assets equally, **we need to modify the ADR formula to reflect a percentage change rather than a fixed dollar change**. For this, we need to adjust our algorithm as follows:

- Define a “
*lookback*” interval (K) - For each period, calculate
*Daily Range %*(DR) as High / Low - Sum all
*Daily Range %*values - Divide by the
*lookback*interval length - Subtract 1 from the DR%
- Multiply by 100

This gives us an ADR representing a percentage change in price which allows comparison between assets with wildly different prices. The following image reflects the update to our ADR algorithm:

We can implement this modified ADR using the following code (using our initial sample data again):

# Get High/Low for each period daily_ranges = [d[1] / d[0] for d in data] # Get SMA of daily Ranges sma = mean(daily_ranges) # Calculate modified_adr = 100 * (sma - 1) >>> 85.0

Note we once again get the same value as illustrated in the image. This is good news—indicating our math is correct—but we’re left once again with a syntactically cumbersome algorithm. Let’s use our `$ETH-USD`

`DataFrame`

and employ a once-again-simplified version of our modified ADR:

# Get pricing data import yfinance as yf # Get the previous 6 months pricing data for ETH ETH = yf.Ticker('ETH-USD').history(period='6mo', interval="1d")[["High", "Low"]] # Calculate Daily Range for each period and normalize as pct change ETH['dr_pct'] = ETH.apply(lambda x: 100 * (x["High"] / x["Low"] - 1), axis=1) # Calculate the average daily range over a 20-period interval ETH["mod_adr"] = ETH['dr_pct'].rolling(window=20).mean() # View Result print(ETH) High Low dr_pct mod_adr Date 2021-05-18 3562.465088 3246.404053 9.735727 NaN 2021-05-19 3437.935791 1952.460205 76.082246 NaN 2021-05-20 2993.145264 2170.229004 37.918407 NaN 2021-05-21 2938.205078 2113.347168 39.030876 NaN 2021-05-22 2483.983154 2168.124268 14.568302 NaN ... ... ... ... ... 2021-11-14 4689.842773 4516.935547 3.827976 5.057539 2021-11-15 4764.636230 4546.599121 4.795609 5.075362 2021-11-16 4891.704590 4144.334961 18.033524 5.507737 2021-11-17 4300.306641 4107.125977 4.703549 5.246916 2021-11-18 4343.557129 3985.766113 8.976719 5.480348 [185 rows x 4 columns]

Looking at the last few rows of data we see a modified ADR value in the range of `5-5.48`

. This reflects an **average daily price range** as a *percentage* movement which, once again, requires the first 19 `dr_pct`

values to have been calculated before the first ADR value will be calculated.

## Average Daily Range (ADR) vs. Average True Range (ATR)

The Average Daily Range reflects the average change in intraday prices over a period of time. The Average True Range is similar but takes into account any gaps in pricing between the closing of one trading period and the opening of the next.

Where ADR uses the High and Low of each period to make a calculation the ATR takes into account the High and Low relative to the previous closing price. This accounts for both gaps up and down in price.

## Final Thoughts

The Average Daily Range can be a useful tool in developing a range of trading strategies. For example, one could use it as a feature to develop a linear regression model to help forecast price changes in an underlying asset. As with most technical indicators, the ADR is often used alongside others rather than a single predictive measure.

Also, keep in mind that the ADR doesn’t reflect gaps up and down in price. For longer trading windows the ATR may serve as a better reflection of volatility. The implementation we’ve seen in this guide hasn’t been optimized for wide-scale use and has been presented with