In this video, we're going to look at three essential algorithms for automating chart patterns and other forms of technical analysis, such as support and resistance levels. The three algorithms provide different approaches for systematically identifying local tops and bottoms in the price. Many chart patterns are built from local tops and bottoms. For example, the Head and Shoulders pattern is built around five local turning points in price. Many other chart patterns are also built from local tops and bottoms. For a human, identifying these turning points is quite easy; you just look. But for a computer, it's not so straightforward. I'll explain three different algorithms to identify turning points and show Python implementations. After that, I'll compare and contrast each algorithm. In the future, I'll create videos that make use of these algorithms to identify well-known chart patterns, find horizontal support and resistance levels, and to data mine novel chart patterns. So subscribe to not miss those. Our first algorithm is the rolling window method. It identifies local tops and bottoms by checking if a point is the highest or lowest point compared to its neighboring points. For example, let's

look at this point here marked with red. We verify that it is a local top by seeing if it is greater than its two adjacent points marked with white. In this case, we only shift one point on either side of the point in question. The number of adjacent points to check is the one parameter for this algorithm. I will call this parameter the order. This red point is a local top of order one, but if we check the two adjacent points, we find a value greater than it marked with orange. Thus, this point is not a top of order two. Here is every local top of order 1 in this sample. Here's every top with order two, and here's every top with order three. As the order increases, the number of local tops we find decreases as we're being more selective. Local bottoms can be found in the same way, but instead, we check if the point in question is less than its neighboring points. Instead, here's every local bottom of order one, order two, and order three. It's important to note since we're focusing on a trading application. These

local tops and bottoms are identified with a lag equal to the order parameter. For example, the top of order 2 marked here in red is not confirmed until the time marked in green. Let's look at the code. This function checks if there is a top of a given order confirmed at the current index. The index of the potential top is delayed by the order given to avoid looking into the future. We check if there is a point that is greater than it on either side. If there is not, we have found a top. Bottoms are found in the same way but with a less than comparison instead. All local extremes can be found by looping through each candle in the data and checking if there is a high or a low. If either is found, we record the index of confirmation, the index of the extreme, and the price of the extreme. The same algorithm is implemented in the scipy library called ARG Rel extrema, but if you choose to use it, be careful you are not cheating with future data. While this algorithm can be used with high and low.

prices of candles. I think using just the clothes is better because if the market made information like this, a local high and low of order 2 would be identified on the same candle, which seems illogical to me. I've seen this algorithm called many different things, and it is a very obvious way to find local tops and bottoms. The second algorithm is directional change, sometimes called zigzag. This algorithm identifies tops and bottoms when the price has retraced a given amount from its most recent high or low price. This algorithm always produces alternating local tops and bottoms. Let's slow down this visualization to better explain. At this point in time, the last confirmed local extreme is a bottom, meaning the next local extreme will be a top. This orange candle is the highest high we have seen since our confirmed bottom. The yellow line is our confirmation line; it is three percent below the high of the orange candle, the highest high. Once the price closes below this level, the price is retraced enough from the high, and the top is confirmed at the high of the

orange candle like so. Now that we've confirmed to this top, we have a new orange candle. It is the lowest low since our confirmed top. This blue line is our new confirmation line. It is three percent above the low of the orange candle. Once the price closes above the Blue Line, the bottom is confirmed, and the process repeats. The percentage we use to define a retracement is the parameter for this algorithm. Here, we use three percent. If it is set to a higher value, local tops and bottoms will be found less often. Set to a lower value, and they will be found more often. The amount of lag to confirm tops and bottoms is undefined. It varies each time. Let's look at the code. We have a function directional change that takes in the close, high, and low, and sigma, which is the percentage retracement. We track the type of the last extreme top or bottom with the Boolean upzig. We arbitrarily initialize it as true. We have to initialize it as something. This may cause the results to be slightly inaccurate at the very beginning of the

data. We keep track of the current index and price of the pending top or bottom, and these variables, these values correspond to the orange candle we saw in the visualization. We loop through each candle in the data set. If the last confirmed extreme was a bottom, we go into this block. If we find a higher high, we update the pending top variables. Otherwise, we check if the price has closed beyond our retracement threshold. If it has, we record a confirmed top, set our upsig Boolean to false, and record the penetrating candle's low for the upcoming bottom. If the last confirmed extreme was a top, we do everything opposite. We check for a lower low and update our pending bottom. Otherwise, we check if a retracement has occurred. If it has, we record our confirmed bottom and set up for the next top. Over time, I've seen several variations of this algorithm. The version of the algorithm I showed uses the candle's high and low prices and a percentage retracement. Using just the closing price as an option, a measure of volatility such as the average true range could be

used to quantify retracements instead of the percentage. Our third algorithm is perceptually important points. This algorithm is given a section of price data and a number of points defined. Let's look at an example. Here's a section of price data. We will find five perceptually important points. The first two are always the first and last points in the data. We then make a line between the two points. We then find the distance from each inner point to the line. The point with the maximum distance is selected as the next point. Lines will be drawn between pairs of adjacent selected points. We look at the distance for each point and again select the one with the maximum distance. We repeat this process once again for the fifth perceptually important point. We could continue for as many points as we desire, but here we only wanted five, so we stop here. Let's look at the code. We implement perceptually important points with this find Pips function. Pips is an acronym for perceptually important points. The function takes an array, the number of

Pips defines and the distance measure. The visualization showed the vertical distance, but Euclidean and perpendicular distance are other options. In my experience, all three of the distance measures often choose the same points, but it's worth testing if one measure has outstanding performance for a particular application. Anyways, we record the index and prices of the selected points and Pips X and Pips Y respectively. We initialize them with the first and last points. This outer loop selects each point until we reach the specified number. We create variables for tracking the max distance found. We then loop through each pair of adjacent points we've bound so far. We find the slope and intercept of the line between the current pair of adjacent points. Then we loop through each point between the current pair of adjacent points. We calculate the distance depending on the selected distance measure. Then check for and record a larger distance if bounds. After looping through each point, we record the point of max distance as the next point. Perceptually important points was introduced in 2001. I have the original

source of the algorithm. Linked In the description. I encourage interested viewers to look at perceptually important points in Google Scholar. There are a ton of interesting papers using this algorithm and financial applications. We looked at three algorithms to identify local tops and bottoms in price. One or more of these algorithms can be used as building blocks for automating chart patterns or other forms of technical analysis. They all use different criteria for finding points of interest in the price. The rolling window method focuses on time. It will find a bottom if a point is the lowest in a neighboring window, but it does not care how much lower a point is as long as it is lower. The rolling window method would identify these two formations as a bottom despite one being more extreme. The directional change method focuses on price. If the retracement threshold was high enough, it could ignore the less extreme bottom shown on the right. The perceptually important points method is quite a bit different from the other two methods. It selects points based on its distance from adjacent selected points. Its focus is Loosely a middle ground.

between the time-focused rolling window method and the price-focused directional change method. Its other major difference is it functions on a slice of data. I've found all three algorithms useful for different applications and technical analysis automation. Sometimes they can be used interchangeably, other times one is a clear choice. I found all three useful for finding chart patterns. Directional change is good for identifying support and resistance levels, and perceptually important points are particularly good for data mining novel patterns with a body of literature behind it. I'll be creating videos that use these algorithms for a variety of trading applications. Cool stuff is coming down the pipes. Subscribe. That's all for this one. Thanks for watching.

3 Must-Know Algorithms for Automating Chart Pattern Trading in Python

3 Must-Know Algorithms for Automating Chart Pattern Trading in Python

Scripts