Highlights<\/h2>\n\n- The history of the RSI, the benefits it brought, and the purpose for its use<\/li>\n
- The parameters used in the RSI for generating overbought and oversold signals<\/li>\n
- The steps required to calculate the RSI including Welles Wilder’s original smoothing function<\/li>\n
- Alternatives to using the Wilder Smoothing Method for calculating average price gains and losses<\/li>\n
- A brief discussion of sliding window algorithms and how they apply to calculate the RSI<\/li>\n
- Three approaches to calculating the RSI in Python, the pros and cons of each, and validation of the resulting data.<\/li>\n<\/ul>\n
Introduction<\/h2>\n
The Relative Strength Index (RSI) is a momentum oscillator that conveys buying and selling pressure in a given market. When applied to a single stock, a low RSI value indicates oversold status and a high value indicates oversold. Values for overbought are usually between 70-80 and those reflecting oversold status are between 20-30. These values can be adjusted based on trader preference.<\/p>\n
The RSI was first introduced by J.Welles Wilder, Jr. in his 1978 book New Concepts in Technical Trading <\/em>(Wilder, 1978). It was introduced as an improvement of current momentum oscillators that didn’t take measure price relative to recent changes.<\/p>\nThe RSI provides recommendations to traders and has applications ranging from single-signal indications to complex combinations with other indicators. These combinations find the RSI integrated into machine learning, genetic, and complex algorithmic trading systems (Boboc, 2013; Tharavanij, 2015.)<\/p>\n
History<\/h2>\n
Section six of Wilder’s\u00a0New Concepts in Technical Trading<\/em> outlines the first-ever public record of RSI calculation. This method made use of what has become known as the Wilder Moving Average\u00a0<\/em> (WMA)<\/strong> (a.k.a. Wilder’s Smoothing Method, Wilder Smoothing, etc.) More on that in a bit.<\/p>\nThe introduction of the RSI starts by discussing tools known as momentum oscillators.<\/strong> Wilder notes the “slope of a momentum oscillator is directly proportional to the velocity of the move. The distance traveled up or down by the momentum<\/strong> oscillator is proportional to the magnitude<\/strong> of the move.” Wilder summarizes this by noting oscillators as measures of the rate of change<\/strong> of price movements.<\/p>\nWilder notes three main issues with the momentum oscillators. These problems, he notes as likely to trip up all but those intimately familiar with the nature of their calculations (read as\u00a0experts<\/em>). These three problems are outlined as follows:<\/p>\n\n- Erratic movements within the oscillator;<\/li>\n
- The scale of the Y-Axis doesn’t afford a relative measure to compare current and previous pricing;<\/li>\n
- The requirement of retaining measures for all past periods to generate new calculations.<\/li>\n<\/ol>\n
The Relative Strength Index (RSI)<\/strong> was then introduced as the solution to the above three problems. It uses a smoothing function to calm the erratic movements within momentum oscillators; it uses a standardization formula to ensure all values are placed on a scale of 0-100 for easy comparison; and finally, it only uses only the most recent periods data to generate the next periods’ value.<\/p>\nNote<\/strong>: The first RSI value requires several previous periods, defined as the lookback period (commonly 14), to generate a value. After that, only the most recent RSI value is required\u2014more on that below.<\/p>\nCalculating the RSI<\/h2>\n
Wilder’s original formula for calculating the RSI was introduced in a stepwise manner along with two primary equations; the Relative Strength Index (RSI)<\/strong> and the Relative Strength (RS)<\/strong>. The RS is a proportional measure of average price gains<\/strong> and average price losses<\/strong> and the RSI provides a standardized value from 0-to 100 to reflect that relationship. The formula for each is as follows:<\/p>\n![\"rsi](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1674\/rsi-formulae-alpharithms.jpg\" "\\"rsi-formulae-alpharithms\\"")
The RSI is calculated in a two-step process that results in a standardized value for the current price relative to past prices.<\/figcaption><\/figure>\nCalculating the RSI first requires the RS which requires an average value of n-many previous trading days. A value of 14 days is common for the RSI calculation; it’s the value Wilder used and also the one we’ll be using for our examples here. The first RS value requires the price from all 14 of the first trading days<\/strong>. This is a common source of confusion with the RSI given successive values only require the most recent. Let’s walk through the process here before we start to develop our code:<\/p>\n\n- For 14 periods, calculate the difference in price<\/strong> from the current period and the previous period;<\/li>\n
- For each period, record each positive change in price as a gain<\/strong> and each negative change as a loss<\/strong>;<\/li>\n
- On the 14th period, calculate the arithmetic mean of the gains and losses for the entire 14 day period (e.g. gains \/ 14 & losses \/ 14);<\/li>\n
- Use these values to calculate the RS<\/li>\n
- Use the RS value to calculate the RSI<\/li>\n
- For each proceeding period, use only the previous RSI value to calculate the next average value by multiplying by our lookback period – 1 (e.g. 13 for a lookback of 14).<\/li>\n
- Add the value obtained in step 6 to the current day’s value (do this for both the gains and losses)<\/li>\n<\/ol>\n
Step 6 implements the first iteration of Wilder’s Smoothing Average (WSA) and involves a more exotic type of weighted moving average. This is illustrated by the formalized by the following equation:<\/p>\n![\"wilder](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1674\/wilder-smoothing-method-alpharithms-1024x576.jpg\" "\\"wilder-smoothing-method-alpharithms\\"")
Wilder’s original smoothing method for RSI calculation. (click to enlarge)<\/figcaption><\/figure>\nThis equation is used to calculate the average gains and losses after the initial number of periods have values. The variables are explained as such:<\/p>\n
\n- WSMpi<\/sub><\/strong> – The current average value (for a gain or loss) (a.k.a WSA)<\/li>\n
- WSMp (i-1)<\/sub><\/strong> – The average value from the previous period (a.k.a WSA)<\/li>\n
- \u03b1 (alpha)<\/strong> – The size of our lookback period<\/li>\n
- p<\/strong> – The current period’s measured price difference<\/li>\n<\/ul>\n
Between the initial instructions and this equation, calculating the RSI sounds like a lot<\/em> of work. To be fair, when introduced by Wilder, it really was. Wilder suggested traders used the following 10-column worksheet to aid in the calculations. See below:<\/p>\n![\"wilder](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1695\/wilder-daily-worksheet-rsi.jpg\" "\\"wilder-daily-worksheet-rsi\\"")
<\/a>The example worksheet by Wilder illustrating the intermediate values for RSI calculation across a 38-period trading window. (Click to Enlarge)<\/figcaption><\/figure>\nThe thought of having to make these calculations for any reasonable number of assets seems excruciating. Keep in mind this was long before intraday trading was available and daily (and often weekly) price action was the primary focus of technical analysis. Still, it highlights the advantages afforded to modern traders by tools like Python.<\/p>\n
Before we start developing the code to calculate the RSI with Python let us first consider our approach. For this type of calculation, we will need to use what is referred to as a sliding window algorithm. This algorithm will be used for calculating our initial averages as well as those to follow.<\/p>\n
Sliding Window Calculations<\/h2>\n
Sliding windows calculations are algorithmic approaches that provide dynamic values from a subset of other values. These approaches are utilized in network communications as part of reliable data transfer protocols (RDP)<\/a> such as TCP\/IP Protocol<\/a> and statistical methods involving rolling averages<\/a>.<\/p>\nBasically, sliding window algorithms have defined a window size that specifies the number of values within a set of values that are to be considered at any given time. For example, a Simple Moving Average (SMA)<\/strong> with a lookback period of 3 days only considers the 3-most recent prices for a stock. In this example, the 3-days represent the sliding window.<\/p>\nAs the next period is considered, the window moves forward one position\u2014while retaining its capacity\u2014such that the oldest value is removed and the next value is added. This approach is described in the following illustration:<\/p>\n![\"sliding](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1674\/sliding-window-diagrap.jpg\" "\\"sliding-window-diagrap\\"")
Illustration of a sliding window calculation such as the one used for SMA and EMA signals.<\/figcaption><\/figure>\nIn the above illustration, each “window” of three values has an average value that can be calculated. The average changes as the window slides<\/em> through the data. This type of average is also referred to as a “rolling” average. As a further example of sliding window calculations, consider the following diagram illustrating the removal of the previous value and addition of the next value into the current window:<\/p>\n![\"sliding](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1674\/sliding-window-iteration-alpharithms-1024x575.jpg\" "\\"sliding-window-iteration-alpharithms\\"")
In a sliding window algorithm, an iterative cycle is completed by removing the oldest value from the window collection and adding the next value.<\/figcaption><\/figure>\nHere we can see that, as the fourth element enters the window, the first element is removed. This represents the transition from the first to the second row in the first image above.\u00a0 Check out this article<\/a> for a more rigorous discussion of sliding window algorithms. The basic understanding we’ve developed here should be enough to help us approach calculating the RSI.<\/p>\nData Preparation<\/h2>\n
We will first approach calculating the RSI using vanilla Python only. Then after having developed a sense of frustration, we will move on to calculating the RSI with some assistance from the Pandas<\/code> library. Then, we will remove the last of our frustrations by implementing a one-liner afforded by the pandas_ta<\/code> library.<\/p>\nFor these calculations, we will be using the sample data given by Wilder in his original introduction of the RSI. This data is available via Github<\/a> as a CSV file containing the period and price. The following code will load the data into Python for our calculations:<\/p>\n# Load the data via Python's CSV module\r\nwith open('wilder-rsi-data.csv', 'r')as file:\r\n reader = csv.reader(file)\r\n header = next(reader) # skip the header\r\n data = [row[1] for row in list(reader)]\r\n\r\n# View the Data\r\nprint (data)\r\n\r\n# Our data, as a native Python List\r\n['54.8', '56.8', '57.85', '59.85', '60.57', '61.1', '62.17', '60.6', '62.35', '62.15', '62.35', '61.45', '62.8', '61.37', '62.5', '62.57', '60.8', '59.37', '60.35', '62.35', '62.17', '62.55', '64.55', '64.37', '65.3', '64.42', '62.9', '61.6', '62.05', '60.05', '59.7', '60.9', '60.25', '58.27', '58.7', '57.72', '58.1', '58.2']\r\n<\/pre>\nCalculating the RSI with Vanilla Python<\/h2>\n
This method will be the most involved with the least amount of abstraction from Wilder’s original instructions. To get started, we need to define some variables and initialize some containers for our sliding windows:<\/p>\n
# Define our Lookback period (our sliding window)\r\nwindow_length = 14\r\n\r\n# Initialize containers for avg. gains and losses\r\ngains = []\r\nlosses = []\r\n\r\n# Create a container for current lookback prices\r\nwindow = []\r\n\r\n# Keeps track of previous average values\r\nprev_avg_gain = None\r\nprev_avg_loss = None\r\n\r\n# Create a container for our final output (as a csv)\r\noutput = [['date', 'close', 'gain', 'loss', 'avg_gain', 'avg_loss', 'rsi']]<\/pre>\nThese variables will aid our calculation of the RSI. The output<\/code> variable isn’t strictly necessary but we’ll use it to save out all of our calculations for comparison with Wilder’s. With our data in hand, we can now start calculating the RSI by first getting the price differences.<\/p>\nNote<\/strong>: All of our steps here will be done within the body of a for loop that is started in the first step below.<\/p>\nStep 1: Calculate the Price Differences<\/h3>\n
Calculating the price difference requires two prices\u2014meaning our first period is effectively a null period for our calculations. We need to add a condition to handle this, and update our final output accordingly:<\/p>\n
# Loop through an enumerated set of our data\r\n# to keep track of which period we are currently\r\n# making calculations for.\r\nfor i, price in enumerate(wilder_data):\r\n\r\n # keep track of the price for the first period\r\n # but don't calculate a difference value.\r\n if i == 0:\r\n window.append(price)\r\n output.append([i+1, price, 0, 0, 0, 0, 0])\r\n continue\r\n\r\n # After the first period, calculate the difference\r\n # between price and previous price as a rounded value\r\n difference = round(wilder_data[i] - wilder_data[i - 1], 2)<\/pre>\nHere we have started our loop using the enumerate(data)<\/code> syntax to provide us with an iterator variable i<\/code> that will serve to easily keep track of which period we are considering. We also add the price to our sliding window (which will need 14 values before the RSI can be calculated) and append a row of data to our final output. After the first row, we calculate our price difference rounded to the nearest 2 decimals.<\/p>\nNote<\/strong>: We are rounding here to keep our final values as close to Wilder’s as possible. We’ll compare the final values of rounded\/non-rounded later to get a feel for the loss of precision here.<\/p>\nStep 2: Calculate the Gains & Losses<\/h3>\n
We will now use the price difference to calculate the gains and losses for each period. Both the gains and losses will be recorded as\u00a0positive values<\/em> meaning given the nature of the RSI. We will record values of 0 for the gains where the difference is negative and 0’s for the losses where the difference is positive.<\/p>\nWe will store these values in a sliding window as well for easy calculation as we move along. We will continue to loop through our prices until we have enough gains and losses to calculate our first RS value (14 periods in our case.) This is coded as such:<\/p>\n
# Record positive differences as gains\r\nif difference > 0:\r\n gain = difference\r\n loss = 0\r\n\r\n# Record negative differences as losses\r\nelif difference < 0:\r\n gain = 0\r\n loss = abs(difference)\r\n\r\n# Record no movements as neutral\r\nelse:\r\n gain = 0\r\n loss = 0\r\n\r\n# Save gains\/losses\r\ngains.append(gain)\r\nlosses.append(loss)\r\n\r\n# Continue to iterate until enough\r\n# gains\/losses data is available to \r\n# calculate the initial RS value\r\nif i < window_length:\r\n window.append(price)\r\n output.append([i+1, price, gain, loss, 0, 0, 0])\r\n continue<\/pre>\nHere we are accumulating the necessary gain and loss values to calculate our first average. We are also appending these data to our final output container as well.<\/p>\n
Step 3: Calculate Average Gains & Losses<\/h3>\n
After our gains and losses accumulate we’ll calculate the Simple Moving Average (SMA)<\/strong> of these values across our lookback period. This is the equivalent of the arithmetic mean and has no weighting factor as used in other methods such as the Exponential Moving Average (EMA)<\/strong> or the Wilder Smoothing Method (WSM)<\/strong>. However, calculations after the initial 14 periods\u00a0will<\/em> use a weighted calculation. This is coded as follows:<\/p>\n# Calculate SMA for first gain\r\nif i == window_length:\r\n avg_gain = sum(gains) \/ len(gains)\r\n avg_loss = sum(losses) \/ len(losses)\r\n\r\n# Use WSM after initial window-length period\r\nelse:\r\n avg_gain = (prev_avg_gain * (window_length - 1) + gain) \/ window_length\r\n avg_loss = (prev_avg_loss * (window_length - 1) + loss) \/ window_length\r\n\r\n# Keep in memory\r\nprev_avg_gain = avg_gain\r\nprev_avg_loss = avg_loss\r\n\r\n# Round for later comparison (optional)\r\navg_gain = round(avg_gain, 2)\r\navg_loss = round(avg_loss, 2)\r\nprev_avg_gain = round(prev_avg_gain, 2)\r\nprev_avg_loss = round(prev_avg_loss, 2)<\/pre>\nThe conditional statement handles the need for 14-periods of initial data and implements the SMA calculation. After that initial phase, we see the implementation of the WMA for calculating both the average gain and loss values using the prev_avg_gain<\/code> and prev_avg_loss<\/code> variables that have been retained from the previous iteration\u2014and updated immediately after our calculations here.<\/p>\nThe implementation of a smoothing method here (WSM) addresses the first problem with momentum oscillators Wilder noted: their erratic movements<\/em>.<\/p>\nNote<\/strong>: We are rounding these values off for later comparison to Wilder’s sample data because that’s how it was implemented in New Concepts in Technical Trading Systems<\/em>. For day-to-day use, these lines of code, along with any other rounding we do here, are not necessary and ill-advised.<\/p>\nStep 4: Calculate the RS Value<\/h3>\n
Here is where all our hard work begins to pay off. There is nothing fancy about this step and we simply implement the division of our average gains and losses to calculate the RS value:<\/p>\n
# use avg. gains and losses to calculate\r\n# the RS value rounded to the nearest \r\n# 2 decimal places\r\nrs = round(avg_gain \/ avg_loss, 2)<\/pre>\nThis value is a numerical representation of the relationship of price action across our lookback period. It affords us insight into the magnitude and velocity but isn’t standardized\u2014the second problem with momentum oscillators noted by Wilder.<\/p>\n
Step 5: Calculate the RSI Value<\/h3>\n
With our RS value in hand, we can now implement Wilder’s RSI formula to standardize our values (make the Relative<\/em>) with the following code:<\/p>\n# use the RS value to calculate the \r\n# RSI to the nearest 2 decimal places\r\nrsi = round(100 - (100 \/ (1 + rs)), 2)<\/pre>\nWith this, our hard work has finally paid off and we’ve addressed the second problem with momentum oscillators and normalized all of our values to the scale of 0-100. This completes our RSI calculation but we need to wrap a few things up to prepare for the next iteration and maintain our output.<\/p>\n
Step 6: House-Keeping<\/h3>\n
This final step is a Python-only requirement and not strictly reflective of any such steps outlined by Wilder. We need to update our sliding windows for gains, losses, and prices and also save our current values as the next line in our output container. This is achieved by the following code:<\/p>\n
# Remove oldest values\r\nwindow.append(price)\r\nwindow.pop(0)\r\ngains.pop(0)\r\nlosses.pop(0)\r\n\r\n# Save Data\r\noutput.append([i+1, price, gain, loss, avg_gain, avg_loss, rsi])<\/pre>\nStep 7: Save Output Data<\/h3>\n
At this point, all our RSI calculations have been made and our output container is holding all the results. We’ll save this out as a CSV file using Python’s standard CSV library so we can easily re-load and compare to Wilder’s calculations without having to crunch all the numbers again. The following code will handle this:<\/p>\n
import csv\r\n\r\n# Create a new CSV file to store output data\r\nwith open('wilder-rsi-data.csv', 'w', newline='') as file:\r\n writer = csv.writer(file)\r\n writer.writerows(output)\r\n<\/pre>\nStep 8: Validation<\/h3>\n
Now we need to ensure our implementation of the RSI is consistent with Wilder’s original specifications. To do this, we’ll compare our output data with the sample calculations provided by Wilder. First, let’s look at our final output data:<\/p>\n
Introduction<\/h2>\n
The Relative Strength Index (RSI) is a momentum oscillator that conveys buying and selling pressure in a given market. When applied to a single stock, a low RSI value indicates oversold status and a high value indicates oversold. Values for overbought are usually between 70-80 and those reflecting oversold status are between 20-30. These values can be adjusted based on trader preference.<\/p>\n
The RSI was first introduced by J.Welles Wilder, Jr. in his 1978 book New Concepts in Technical Trading <\/em>(Wilder, 1978). It was introduced as an improvement of current momentum oscillators that didn’t take measure price relative to recent changes.<\/p>\n The RSI provides recommendations to traders and has applications ranging from single-signal indications to complex combinations with other indicators. These combinations find the RSI integrated into machine learning, genetic, and complex algorithmic trading systems (Boboc, 2013; Tharavanij, 2015.)<\/p>\n Section six of Wilder’s\u00a0New Concepts in Technical Trading<\/em> outlines the first-ever public record of RSI calculation. This method made use of what has become known as the Wilder Moving Average\u00a0<\/em> (WMA)<\/strong> (a.k.a. Wilder’s Smoothing Method, Wilder Smoothing, etc.) More on that in a bit.<\/p>\n The introduction of the RSI starts by discussing tools known as momentum oscillators.<\/strong> Wilder notes the “slope of a momentum oscillator is directly proportional to the velocity of the move. The distance traveled up or down by the momentum<\/strong> oscillator is proportional to the magnitude<\/strong> of the move.” Wilder summarizes this by noting oscillators as measures of the rate of change<\/strong> of price movements.<\/p>\n Wilder notes three main issues with the momentum oscillators. These problems, he notes as likely to trip up all but those intimately familiar with the nature of their calculations (read as\u00a0experts<\/em>). These three problems are outlined as follows:<\/p>\n The Relative Strength Index (RSI)<\/strong> was then introduced as the solution to the above three problems. It uses a smoothing function to calm the erratic movements within momentum oscillators; it uses a standardization formula to ensure all values are placed on a scale of 0-100 for easy comparison; and finally, it only uses only the most recent periods data to generate the next periods’ value.<\/p>\n Note<\/strong>: The first RSI value requires several previous periods, defined as the lookback period (commonly 14), to generate a value. After that, only the most recent RSI value is required\u2014more on that below.<\/p>\n Wilder’s original formula for calculating the RSI was introduced in a stepwise manner along with two primary equations; the Relative Strength Index (RSI)<\/strong> and the Relative Strength (RS)<\/strong>. The RS is a proportional measure of average price gains<\/strong> and average price losses<\/strong> and the RSI provides a standardized value from 0-to 100 to reflect that relationship. The formula for each is as follows:<\/p>\n Calculating the RSI first requires the RS which requires an average value of n-many previous trading days. A value of 14 days is common for the RSI calculation; it’s the value Wilder used and also the one we’ll be using for our examples here. The first RS value requires the price from all 14 of the first trading days<\/strong>. This is a common source of confusion with the RSI given successive values only require the most recent. Let’s walk through the process here before we start to develop our code:<\/p>\n Step 6 implements the first iteration of Wilder’s Smoothing Average (WSA) and involves a more exotic type of weighted moving average. This is illustrated by the formalized by the following equation:<\/p>\n This equation is used to calculate the average gains and losses after the initial number of periods have values. The variables are explained as such:<\/p>\n Between the initial instructions and this equation, calculating the RSI sounds like a lot<\/em> of work. To be fair, when introduced by Wilder, it really was. Wilder suggested traders used the following 10-column worksheet to aid in the calculations. See below:<\/p>\n The thought of having to make these calculations for any reasonable number of assets seems excruciating. Keep in mind this was long before intraday trading was available and daily (and often weekly) price action was the primary focus of technical analysis. Still, it highlights the advantages afforded to modern traders by tools like Python.<\/p>\n Before we start developing the code to calculate the RSI with Python let us first consider our approach. For this type of calculation, we will need to use what is referred to as a sliding window algorithm. This algorithm will be used for calculating our initial averages as well as those to follow.<\/p>\n Sliding windows calculations are algorithmic approaches that provide dynamic values from a subset of other values. These approaches are utilized in network communications as part of reliable data transfer protocols (RDP)<\/a> such as TCP\/IP Protocol<\/a> and statistical methods involving rolling averages<\/a>.<\/p>\n Basically, sliding window algorithms have defined a window size that specifies the number of values within a set of values that are to be considered at any given time. For example, a Simple Moving Average (SMA)<\/strong> with a lookback period of 3 days only considers the 3-most recent prices for a stock. In this example, the 3-days represent the sliding window.<\/p>\n As the next period is considered, the window moves forward one position\u2014while retaining its capacity\u2014such that the oldest value is removed and the next value is added. This approach is described in the following illustration:<\/p>\n In the above illustration, each “window” of three values has an average value that can be calculated. The average changes as the window slides<\/em> through the data. This type of average is also referred to as a “rolling” average. As a further example of sliding window calculations, consider the following diagram illustrating the removal of the previous value and addition of the next value into the current window:<\/p>\n Here we can see that, as the fourth element enters the window, the first element is removed. This represents the transition from the first to the second row in the first image above.\u00a0 Check out this article<\/a> for a more rigorous discussion of sliding window algorithms. The basic understanding we’ve developed here should be enough to help us approach calculating the RSI.<\/p>\n We will first approach calculating the RSI using vanilla Python only. Then after having developed a sense of frustration, we will move on to calculating the RSI with some assistance from the For these calculations, we will be using the sample data given by Wilder in his original introduction of the RSI. This data is available via Github<\/a> as a CSV file containing the period and price. The following code will load the data into Python for our calculations:<\/p>\n This method will be the most involved with the least amount of abstraction from Wilder’s original instructions. To get started, we need to define some variables and initialize some containers for our sliding windows:<\/p>\n These variables will aid our calculation of the RSI. The Note<\/strong>: All of our steps here will be done within the body of a for loop that is started in the first step below.<\/p>\n Calculating the price difference requires two prices\u2014meaning our first period is effectively a null period for our calculations. We need to add a condition to handle this, and update our final output accordingly:<\/p>\n Here we have started our loop using the Note<\/strong>: We are rounding here to keep our final values as close to Wilder’s as possible. We’ll compare the final values of rounded\/non-rounded later to get a feel for the loss of precision here.<\/p>\n We will now use the price difference to calculate the gains and losses for each period. Both the gains and losses will be recorded as\u00a0positive values<\/em> meaning given the nature of the RSI. We will record values of 0 for the gains where the difference is negative and 0’s for the losses where the difference is positive.<\/p>\n We will store these values in a sliding window as well for easy calculation as we move along. We will continue to loop through our prices until we have enough gains and losses to calculate our first RS value (14 periods in our case.) This is coded as such:<\/p>\n Here we are accumulating the necessary gain and loss values to calculate our first average. We are also appending these data to our final output container as well.<\/p>\n After our gains and losses accumulate we’ll calculate the Simple Moving Average (SMA)<\/strong> of these values across our lookback period. This is the equivalent of the arithmetic mean and has no weighting factor as used in other methods such as the Exponential Moving Average (EMA)<\/strong> or the Wilder Smoothing Method (WSM)<\/strong>. However, calculations after the initial 14 periods\u00a0will<\/em> use a weighted calculation. This is coded as follows:<\/p>\n The conditional statement handles the need for 14-periods of initial data and implements the SMA calculation. After that initial phase, we see the implementation of the WMA for calculating both the average gain and loss values using the The implementation of a smoothing method here (WSM) addresses the first problem with momentum oscillators Wilder noted: their erratic movements<\/em>.<\/p>\n Note<\/strong>: We are rounding these values off for later comparison to Wilder’s sample data because that’s how it was implemented in New Concepts in Technical Trading Systems<\/em>. For day-to-day use, these lines of code, along with any other rounding we do here, are not necessary and ill-advised.<\/p>\n Here is where all our hard work begins to pay off. There is nothing fancy about this step and we simply implement the division of our average gains and losses to calculate the RS value:<\/p>\n This value is a numerical representation of the relationship of price action across our lookback period. It affords us insight into the magnitude and velocity but isn’t standardized\u2014the second problem with momentum oscillators noted by Wilder.<\/p>\n With our RS value in hand, we can now implement Wilder’s RSI formula to standardize our values (make the Relative<\/em>) with the following code:<\/p>\n With this, our hard work has finally paid off and we’ve addressed the second problem with momentum oscillators and normalized all of our values to the scale of 0-100. This completes our RSI calculation but we need to wrap a few things up to prepare for the next iteration and maintain our output.<\/p>\n This final step is a Python-only requirement and not strictly reflective of any such steps outlined by Wilder. We need to update our sliding windows for gains, losses, and prices and also save our current values as the next line in our output container. This is achieved by the following code:<\/p>\n At this point, all our RSI calculations have been made and our output container is holding all the results. We’ll save this out as a CSV file using Python’s standard CSV library so we can easily re-load and compare to Wilder’s calculations without having to crunch all the numbers again. The following code will handle this:<\/p>\n Now we need to ensure our implementation of the RSI is consistent with Wilder’s original specifications. To do this, we’ll compare our output data with the sample calculations provided by Wilder. First, let’s look at our final output data:<\/p>\nHistory<\/h2>\n
\n
Calculating the RSI<\/h2>\n
\n
\n
<\/a>Sliding Window Calculations<\/h2>\n
Data Preparation<\/h2>\n
Pandas<\/code> library. Then, we will remove the last of our frustrations by implementing a one-liner afforded by the pandas_ta<\/code> library.<\/p>\n# Load the data via Python's CSV module\r\nwith open('wilder-rsi-data.csv', 'r')as file:\r\n reader = csv.reader(file)\r\n header = next(reader) # skip the header\r\n data = [row[1] for row in list(reader)]\r\n\r\n# View the Data\r\nprint (data)\r\n\r\n# Our data, as a native Python List\r\n['54.8', '56.8', '57.85', '59.85', '60.57', '61.1', '62.17', '60.6', '62.35', '62.15', '62.35', '61.45', '62.8', '61.37', '62.5', '62.57', '60.8', '59.37', '60.35', '62.35', '62.17', '62.55', '64.55', '64.37', '65.3', '64.42', '62.9', '61.6', '62.05', '60.05', '59.7', '60.9', '60.25', '58.27', '58.7', '57.72', '58.1', '58.2']\r\n<\/pre>\nCalculating the RSI with Vanilla Python<\/h2>\n
# Define our Lookback period (our sliding window)\r\nwindow_length = 14\r\n\r\n# Initialize containers for avg. gains and losses\r\ngains = []\r\nlosses = []\r\n\r\n# Create a container for current lookback prices\r\nwindow = []\r\n\r\n# Keeps track of previous average values\r\nprev_avg_gain = None\r\nprev_avg_loss = None\r\n\r\n# Create a container for our final output (as a csv)\r\noutput = [['date', 'close', 'gain', 'loss', 'avg_gain', 'avg_loss', 'rsi']]<\/pre>\n
output<\/code> variable isn’t strictly necessary but we’ll use it to save out all of our calculations for comparison with Wilder’s. With our data in hand, we can now start calculating the RSI by first getting the price differences.<\/p>\nStep 1: Calculate the Price Differences<\/h3>\n
# Loop through an enumerated set of our data\r\n# to keep track of which period we are currently\r\n# making calculations for.\r\nfor i, price in enumerate(wilder_data):\r\n\r\n # keep track of the price for the first period\r\n # but don't calculate a difference value.\r\n if i == 0:\r\n window.append(price)\r\n output.append([i+1, price, 0, 0, 0, 0, 0])\r\n continue\r\n\r\n # After the first period, calculate the difference\r\n # between price and previous price as a rounded value\r\n difference = round(wilder_data[i] - wilder_data[i - 1], 2)<\/pre>\n
enumerate(data)<\/code> syntax to provide us with an iterator variable i<\/code> that will serve to easily keep track of which period we are considering. We also add the price to our sliding window (which will need 14 values before the RSI can be calculated) and append a row of data to our final output. After the first row, we calculate our price difference rounded to the nearest 2 decimals.<\/p>\nStep 2: Calculate the Gains & Losses<\/h3>\n
# Record positive differences as gains\r\nif difference > 0:\r\n gain = difference\r\n loss = 0\r\n\r\n# Record negative differences as losses\r\nelif difference < 0:\r\n gain = 0\r\n loss = abs(difference)\r\n\r\n# Record no movements as neutral\r\nelse:\r\n gain = 0\r\n loss = 0\r\n\r\n# Save gains\/losses\r\ngains.append(gain)\r\nlosses.append(loss)\r\n\r\n# Continue to iterate until enough\r\n# gains\/losses data is available to \r\n# calculate the initial RS value\r\nif i < window_length:\r\n window.append(price)\r\n output.append([i+1, price, gain, loss, 0, 0, 0])\r\n continue<\/pre>\n
Step 3: Calculate Average Gains & Losses<\/h3>\n
# Calculate SMA for first gain\r\nif i == window_length:\r\n avg_gain = sum(gains) \/ len(gains)\r\n avg_loss = sum(losses) \/ len(losses)\r\n\r\n# Use WSM after initial window-length period\r\nelse:\r\n avg_gain = (prev_avg_gain * (window_length - 1) + gain) \/ window_length\r\n avg_loss = (prev_avg_loss * (window_length - 1) + loss) \/ window_length\r\n\r\n# Keep in memory\r\nprev_avg_gain = avg_gain\r\nprev_avg_loss = avg_loss\r\n\r\n# Round for later comparison (optional)\r\navg_gain = round(avg_gain, 2)\r\navg_loss = round(avg_loss, 2)\r\nprev_avg_gain = round(prev_avg_gain, 2)\r\nprev_avg_loss = round(prev_avg_loss, 2)<\/pre>\n
prev_avg_gain<\/code> and prev_avg_loss<\/code> variables that have been retained from the previous iteration\u2014and updated immediately after our calculations here.<\/p>\nStep 4: Calculate the RS Value<\/h3>\n
# use avg. gains and losses to calculate\r\n# the RS value rounded to the nearest \r\n# 2 decimal places\r\nrs = round(avg_gain \/ avg_loss, 2)<\/pre>\n
Step 5: Calculate the RSI Value<\/h3>\n
# use the RS value to calculate the \r\n# RSI to the nearest 2 decimal places\r\nrsi = round(100 - (100 \/ (1 + rs)), 2)<\/pre>\n
Step 6: House-Keeping<\/h3>\n
# Remove oldest values\r\nwindow.append(price)\r\nwindow.pop(0)\r\ngains.pop(0)\r\nlosses.pop(0)\r\n\r\n# Save Data\r\noutput.append([i+1, price, gain, loss, avg_gain, avg_loss, rsi])<\/pre>\n
Step 7: Save Output Data<\/h3>\n
import csv\r\n\r\n# Create a new CSV file to store output data\r\nwith open('wilder-rsi-data.csv', 'w', newline='') as file:\r\n writer = csv.writer(file)\r\n writer.writerows(output)\r\n<\/pre>\nStep 8: Validation<\/h3>\n
![\"rsi](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1695\/rsi-visualization-btc-usd-1024x484.jpg\" "\\"rsi-visualization-btc-usd\\"")
<\/a>![\"plot](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1695\/plot-and-subplots-plotly-mouse-over-effects-1024x576.jpg\" "\\"plot-and-subplots-plotly-mouse-over-effects\\"")
<\/a>