Elliott Wave Theory is a powerful tool utilized by traders to predict market movements and understand price trends. Developed by Ralph Nelson Elliott in the 1930s, this analysis method is based on the idea that market prices move in identifiable cycles that reflect the emotions and behaviors of market participants. In this blog post, we will dive deep into the principles of Elliott Wave Theory, provide a sample Python strategy script to implement it, and explore how it can enhance your trading strategies.

What Is Elliott Wave Theory?

Elliott Wave Theory posits that markets move in repetitive cycles due to the psychology of investors. These cycles consist of five waves in the direction of the trend (impulse waves) followed by three corrective waves (corrective phases).

• Impulse Waves: These are labeled as waves 1, 2, 3, 4, and 5. Waves 1, 3, and 5 move in the same direction as the trend, while waves 2 and 4 are corrective.
• Corrective Waves: Labeled as A, B, and C, these waves move against the prevailing trend.

The Structure of Elliott Waves

• Five-Wave Pattern: The upward movement consists of five waves (1, 2, 3, 4, 5). Wave 1 starts the uptrend, wave 2 is a correction, wave 3 is the longest, wave 4 is another correction, and wave 5 completes the trend.
• Three-Wave Correction: After the five-wave impulse, the market typically undergoes a corrective phase consisting of three waves (A, B, C).

Why Use Elliott Wave Theory?

• Market Timing: By identifying wave patterns, traders can potentially time their entries and exits more effectively.
• Price Targeting: The theory can help set price targets based on previous wave patterns.
• Risk Management: Understanding where corrections may occur allows traders to better manage their risks.

Implementing Elliott Wave Theory with Python

In the following, we will explore a trading strategy based on the "Three Wave Down Pattern" using ALGOGENE Python framework for backtesting. This strategy targets specific market conditions to make informed market entry decisions.

Trading Logic Overview

We define the conditions for the Three Wave Down Pattern as follows:

• Fifth Day: The price decreases by more than 4%.
• Fourth Day: The price increases but by less than 3%.
• Third Day: The price can either increase or decrease, but not exceed a 1% increase.
• Second Day: The price decreases by more than 2%.
• Recent Day: The price decreases by more than 1%.

Additionally, the strategy ensures that:

• Earnings per share (EPS) are positive to avoid underlying issues with the stock.
• A maximum holding period of 5 days is observed, and the maximum number of stocks held is limited to 2.

After seeing corrective waves (A,B,C), we expect an impulse wave will come next and therefore it suggest a buy signal.

Python Script

Here's the complete Python script implementing the trading logic:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

from AlgoAPI import AlgoAPIUtil, AlgoAPI_Backtest
from datetime import datetime, timedelta

class AlgoEvent:
    def __init__(self):
        self.periods = 5 #max holding period
        self.hold_days = {}
        self.stocks = ["AAPL", "TSLA", "MSFT", "GOOG", "AMZN"]
        self.holdMax = 2 #max hold 2 stocks
        self.timer = datetime(1970,1,1)

    def start(self, mEvt):
        self.evt = AlgoAPI_Backtest.AlgoEvtHandler(self, mEvt)
        self.stocks = mEvt['subscribeList']
        self.evt.start()

    def on_bulkdatafeed(self, isSync, bd, ab):
        timestamp = bd[self.stocks[0]]['timestamp']
        if timestamp>=self.timer+timedelta(days=1):
            self.timer = timestamp
        else:
            return

        # open order logic
        pos, _, _ = self.evt.getSystemOrders()
        if sum([1 for stock in pos if pos[stock]['netVolume']!=0]) < self.holdMax:

            available_cash = ab['availableBalance']
            cash_per_stock = available_cash / (self.holdMax - len(pos)) if (self.holdMax - len(pos)) > 0 else 0

            for stock in bd:
                data = self.evt.getHistoricalBar({'instrument': stock}, 5, 'D')
                if not data or len(data) < 5:
                    continue

                prices = [data[d]['c'] for d in sorted(data)]
                roc = [(prices[i] - prices[i-1])/prices[i-1] for i in range(1,len(prices))]
                try:
                    if len(roc) >=4 and roc[3]<-0.04 and roc[2]>0 and roc[2]<0.03 and roc[1]<0.01 and roc[0]<-0.02:
                        if stock not in self.hold_days and stock not in pos[stock]==0:
                            volume = int(cash_per_stock / bd[stock].close)
                            order = AlgoAPIUtil.OrderObject(
                                instrument=stock, 
                                openclose='open', 
                                buysell=1, 
                                ordertype=0, 
                                volume=volume
                            )
                            self.evt.sendOrder(order)
                            self.hold_days[stock] = 0
                            self.evt.consoleLog(f"Buying {stock} at {bd[stock].close}")
                except Exception as e:
                    self.evt.consoleLog(f"Error processing {stock}: {e}")

        # close order logic
        _, current_orders, _ = self.evt.getSystemOrders()
        for tradeID in list(current_orders):
            order = current_orders[tradeID]
            opentime = order['opentime']

            if timestamp > opentime + timedelta(days=self.periods):
                order = AlgoAPIUtil.OrderObject(
                    tradeID=tradeID,
                    openclose='close'
                )
                self.evt.sendOrder(order)
                del self.hold_days[stock]
                self.evt.consoleLog(f"Selling {stock} after {self.periods} days")

Tips for Trading with Elliott Wave Theory

To maximize the effectiveness of above backtesting framework, ensure you:

1. Adjust parameters based on your investment goals.
2. Combine with other indicators such as Fibonacci retracements, moving averages, and volume analysis to confirm wave counts.
3. Continuously review and refine your strategy based on results from backtesting to align with real market conditions.
4. Elliott Wave patterns are subjective, leading to varied interpretations among traders. Practicing wave counting on historical charts can enhance your ability to identify patterns and improve trading accuracy.

Conclusion

Elliott Wave Theory provides traders with a framework to understand market dynamics and make informed trading decisions. By recognizing wave patterns, traders can better time their market entries and exits while effectively managing risk.

If you wish to broaden your trading toolkit, don’t hesitate to explore various resources and communities dedicated to Elliott Wave analysis. Implementing this theory into your trading strategy may significantly improve your market performance.