Equity · Global · ETFs · Daily · Global Free
Double Bottom Country Trading Strategy

Academic paper

AuthorsCyril Dujava; Filip Kalús; Radovan Vojtko; Quantpedia
Institute
?Quantpedia
?Quantpedia.com
Paper linkhttps://papers.ssrn.com/sol3/papers.cfm?abstract_id=4549609
Strategy in a nutshell

Trade 24 country ETFs (e.g., SPY, FXI, MSCI funds). Identify double bottoms in long-term uptrends using 30-day rolling windows. Entry via limit orders at bottoms, with 3% trailing stop-loss and 6% profit target (R:R = 1:2). Max 4 positions, 2:1 leverage. Monthly scanning, daily trade execution.
Economic rationale

Technical analysis captures market psychology alongside fundamentals. While imperfect, price patterns like double bottoms reflect investor behavior and information assimilation. TA provides practical insights beyond fundamental analysis alone.
Backtest performance

Annualised return7.79%
Volatility16.57%
Beta0.103
Sharpe ratio0.47
Sortino ratio0.181
Maximum drawdown-30.38%
Win rate53%
Full Python code

1from AlgorithmImports import *
2from pandas.core.frame import DataFrame
3from datetime import datetime
4# endregion
5
6class DoubleBottomCountryTradingStrategy(QCAlgorithm):
7
8def Initialize(self) -> None:
9self.SetStartDate(2000, 1, 1)
10self.SetCash(100000)
11
12self.country_etfs:List[str] = [
13    "EWA",  # iShares MSCI Australia Index ETF
14    "EWO",  # iShares MSCI Austria Investable Mkt Index ETF
15    "EWK",  # iShares MSCI Belgium Investable Market Index ETF
16    "EWZ",  # iShares MSCI Brazil Index ETF
17    "EWC",  # iShares MSCI Canada Index ETF
18    "FXI",  # iShares China Large-Cap ETF
19    "EWQ",  # iShares MSCI France Index ETF
20    "EWG",  # iShares MSCI Germany ETF 
21    "EWH",  # iShares MSCI Hong Kong Index ETF
22    "EWI",  # iShares MSCI Italy Index ETF
23    "EWJ",  # iShares MSCI Japan Index ETF
24    "EWM",  # iShares MSCI Malaysia Index ETF
25    "EWW",  # iShares MSCI Mexico Inv. Mt. Idx
26    "EWN",  # iShares MSCI Netherlands Index ETF
27    "EWS",  # iShares MSCI Singapore Index ETF
28    "EZA",  # iShares MSCI South Africe Index ETF
29    "EWY",  # iShares MSCI South Korea ETF
30    "EWP",  # iShares MSCI Spain Index ETF
31    "EWD",  # iShares MSCI Sweden Index ETF
32    "EWL",  # iShares MSCI Switzerland Index ETF
33    "EWT",  # iShares MSCI Taiwan Index ETF
34    "THD",  # iShares MSCI Thailand Index ETF
35    "EWU",  # iShares MSCI United Kingdom Index ETF
36    "SPY",  # SPDR S&P 500 ETF
37]
38
39self.rolling_period:int = 30
40
41# two local highs/lows max and min distance
42self.min_distance:int = self.rolling_period
43self.max_distance:int = 1000
44
45# max vertical distance between two local highs/lows
46self.max_percentage:float = .02
47
48self.stop_loss_pct:float = .03
49self.take_profit_pct:float = .06
50
51self.trade_long = True
52self.trade_short = False
53self.max_positions_opened:int = 4
54
55self.SetWarmup(self.max_distance, Resolution.Daily)
56
57self.price_data:Dict[str, List[Tuple(datetime.date, float)]] = {}
58
59# add Forex data
60for etf in self.country_etfs:
61    data:Equity = self.AddEquity(etf, Resolution.Daily)
62    data.SetLeverage(10)
63    self.price_data[etf] = []
64
65self.recent_month:int = -1
66
67def OnData(self, data: Slice) -> None:
68# trail long SL for each opened positions
69active_open_buy_orders:List = list(self.Transactions.GetOrderTickets(lambda ticket: 'LIMIT_BUY' in ticket.Tag and ticket.Status == OrderStatus.Filled))
70for ticket in active_open_buy_orders:
71    if self.Portfolio[ticket.Symbol].IsLong:
72        active_sl_orders:List = list(self.Transactions.GetOrderTickets(lambda sl_ticket: 'SL' in sl_ticket.Tag \
73                                    and sl_ticket.Symbol == ticket.Symbol \
74                                    and sl_ticket.Status not in [OrderStatus.Filled, OrderStatus.Invalid, OrderStatus.Canceled]))
75
76        if len(active_sl_orders) != 0:
77            active_sl_order = active_sl_orders[0]
78            # price moved into profit
79            if self.Securities[ticket.Symbol].Price > ticket.Get(OrderField.LimitPrice):
80                new_sl_price:float = round(self.Securities[ticket.Symbol].Price - (self.Securities[ticket.Symbol].Price * self.stop_loss_pct), 2)
81                if new_sl_price > active_sl_order.Get(OrderField.StopPrice):
82                    active_sl_order.UpdateStopPrice(new_sl_price)
83
84# trail short SL for each opened positions
85active_open_buy_orders:List = list(self.Transactions.GetOrderTickets(lambda ticket: 'LIMIT_SELL' in ticket.Tag and ticket.Status == OrderStatus.Filled))
86for ticket in active_open_buy_orders:
87    if self.Portfolio[ticket.Symbol].IsShort:
88        active_sl_orders:List = list(self.Transactions.GetOrderTickets(lambda sl_ticket: 'SL' in sl_ticket.Tag \
89                                    and sl_ticket.Symbol == ticket.Symbol \
90                                    and sl_ticket.Status not in [OrderStatus.Filled, OrderStatus.Invalid, OrderStatus.Canceled]))
91
92        if len(active_sl_orders) != 0:
93            active_sl_order = active_sl_orders[0]
94            # price moved into profit
95            if self.Securities[ticket.Symbol].Price < ticket.Get(OrderField.LimitPrice):
96                new_sl_price:float = round(self.Securities[ticket.Symbol].Price + (self.Securities[ticket.Symbol].Price * self.stop_loss_pct), 2)
97                if new_sl_price < active_sl_order.Get(OrderField.StopPrice):
98                    active_sl_order.UpdateStopPrice(new_sl_price)
99
100# look for new double top and double bottom once a month
101rebalance_flag = False
102if self.recent_month != self.Time.month:
103    rebalance_flag = True
104    self.recent_month = self.Time.month
105
106# store daily prices
107for etf in self.country_etfs:
108    if etf in data and data[etf]:
109        self.price_data[etf].append( (self.Time, data[etf].Value) )
110    
111    if not rebalance_flag:
112        continue
113
114    if len(self.price_data[etf]) >= self.max_distance:
115        if not self.Portfolio[etf].Invested:
116            etf_hist:DataFrame = pd.DataFrame(self.price_data[etf], columns=['Date', etf])
117            etf_hist.set_index('Date', inplace=True)
118            current_datetime:datetime = etf_hist.index[-1]
119            etf_hist = self.find_support_and_resistance(etf, etf_hist, self.rolling_period, self.min_distance)
120            etf_hist = self.find_double_tops_and_bottoms(etf, etf_hist, self.min_distance, self.max_distance, self.max_percentage)                    
121
122            if self.trade_long:
123                # find not yet crossed bottom
124                last_bottom_datetime:DataFrame = etf_hist[~etf_hist['Double_Bottom'].isnull()]
125                if not last_bottom_datetime.empty:
126                    last_bottom_datetime:datetime = last_bottom_datetime.index[-1]
127                    if all(x[1][etf] >= etf_hist.loc[last_bottom_datetime][etf] for x in etf_hist.loc[last_bottom_datetime:current_datetime].iterrows()):
128                        limit_price:float = round(etf_hist.loc[last_bottom_datetime][etf], 2)
129                        active_limit_orders:List = list(self.Transactions.GetOrderTickets(lambda order_ticket: order_ticket.Status not in [OrderStatus.Filled, OrderStatus.Invalid, OrderStatus.Canceled] and order_ticket.Symbol == etf and 'LIMIT_BUY' in order_ticket.Tag))
130
131                        # submit orders
132                        if len(active_limit_orders) != 0:
133                            active_order = active_limit_orders[0]
134                            # there is active order for different price
135                            if active_order.Get(OrderField.LimitPrice) != limit_price:
136                                new_quantity:int = self.Portfolio.TotalPortfolioValue // limit_price
137                                active_order.UpdateLimitPrice(limit_price)
138                                active_order.UpdateQuantity(new_quantity)
139                        else:
140                            # submit new limit order
141                            if len([x for x in self.Portfolio if x.Value.Invested]) < self.max_positions_opened:
142                                quantity:int = self.Portfolio.TotalPortfolioValue // limit_price
143                                if abs(quantity) > 1:
144                                    self.LimitOrder(etf, quantity, limit_price, tag='LIMIT_BUY')
145
146            if self.trade_short:
147                # find not yet crossed top
148                last_top_datetime = etf_hist[~etf_hist['Double_Top'].isnull()]
149                if not last_top_datetime.empty:
150                    last_top_datetime = last_top_datetime.index[-1]
151                    if all(x[1][etf] <= etf_hist.loc[last_top_datetime][etf] for x in etf_hist.loc[last_top_datetime:current_datetime].iterrows()):
152                        limit_price:float = round(etf_hist.loc[last_top_datetime][etf], 2)
153                        active_limit_orders:List = list(self.Transactions.GetOrderTickets(lambda order_ticket: order_ticket.Status not in [OrderStatus.Filled, OrderStatus.Invalid, OrderStatus.Canceled] and order_ticket.Symbol == etf and 'LIMIT_SELL' in order_ticket.Tag))
154
155                        # submit orders
156                        if len(active_limit_orders) != 0:
157                            active_order = active_limit_orders[0]
158                            # there is active order for different price
159                            if active_order.Get(OrderField.LimitPrice) != limit_price:
160                                new_quantity:int = self.Portfolio.TotalPortfolioValue // limit_price
161                                active_order.UpdateLimitPrice(limit_price)
162                                active_order.UpdateQuantity(-new_quantity)
163                        else:
164                            # submit new limit order
165                            if len([x for x in self.Portfolio if x.Value.Invested]) < self.max_positions_opened:
166                                quantity:int = self.Portfolio.TotalPortfolioValue // limit_price
167                                if abs(quantity) > 1:
168                                    self.LimitOrder(etf, -quantity, limit_price, tag='LIMIT_SELL')
169
170def cancel_all_limit_orders(self) -> None:
171# cancel all submitted limit orders for the symbol
172active_limit_orders:List = list(self.Transactions.GetOrderTickets(lambda ticket: ('LIMIT_SELL' in ticket.Tag or 'LIMIT_BUY' in ticket.Tag) and ticket.Status not in [OrderStatus.Filled, OrderStatus.Invalid, OrderStatus.Canceled]))
173for ticket in active_limit_orders:
174    response = ticket.Cancel()
175
176def cancel_all_orders(self, symbol:Symbol) -> None:
177# cancel all submitted orders for the symbol
178active_limit_orders:List = list(self.Transactions.GetOrderTickets(lambda ticket: ticket.Symbol == symbol))
179for ticket in active_limit_orders:
180    response = ticket.Cancel()
181
182def OnOrderEvent(self, orderEvent: OrderEvent) -> None:
183order = self.Transactions.GetOrderById(orderEvent.OrderId)
184if orderEvent.Status == OrderStatus.Filled:
185    order_ticket = self.Transactions.GetOrderTicket(orderEvent.OrderId)
186    
187    # if TP or SL was hit
188    if '_TP' in order_ticket.Tag or '_SL' in order_ticket.Tag:
189        # cancel all submitted orders for the symbol
190        self.cancel_all_orders(order_ticket.Symbol)
191
192    # set TP and SL if limit was hit
193    if orderEvent.Quantity > 0:
194        if 'LIMIT_BUY' in order_ticket.Tag:
195            if len([x for x in self.Portfolio if x.Value.Invested]) == self.max_positions_opened:
196                self.cancel_all_limit_orders()
197
198            tp_price:float = round(orderEvent.FillPrice + (orderEvent.FillPrice * self.take_profit_pct), 2)
199            stop_price:float = round(orderEvent.FillPrice - (orderEvent.FillPrice * self.stop_loss_pct), 2)
200
201            self.LimitOrder(orderEvent.Symbol, -orderEvent.Quantity, tp_price, tag='BUY_TP')
202            self.StopMarketOrder(orderEvent.Symbol, -orderEvent.Quantity, stop_price, tag='BUY_SL')
203    
204    if orderEvent.Quantity < 0:
205        if 'LIMIT_SELL' in order_ticket.Tag:
206            if len([x for x in self.Portfolio if x.Value.Invested]) == self.max_positions_opened:
207                self.cancel_all_limit_orders()
208
209            tp_price:float = round(orderEvent.FillPrice - (orderEvent.FillPrice * self.take_profit_pct), 2)
210            stop_price:float = round(orderEvent.FillPrice + (orderEvent.FillPrice * self.stop_loss_pct), 2)
211            
212            self.LimitOrder(orderEvent.Symbol, -orderEvent.Quantity, tp_price, tag='SELL_TP')
213            self.StopMarketOrder(orderEvent.Symbol, -orderEvent.Quantity, stop_price, tag='SELL_SL')
214
215def find_support_and_resistance(self, symbol:str, stock_data:DataFrame, rolling_period:int, lookback_period:int) -> DataFrame:
216for level_str, obj_function in [('Support', 'min'), ('Resistance', 'max')]:
217    level_prices = stock_data[symbol]
218    # TODO eval min and max
219    if obj_function == 'min':
220        pivot_level = level_prices.rolling(window=rolling_period*2+1, center=True).min().shift(-rolling_period)
221    else:
222        pivot_level = level_prices.rolling(window=rolling_period*2+1, center=True).max().shift(-rolling_period)
223    stock_data[level_str] = None
224
225    level_points = pivot_level.where(pivot_level == level_prices, None).dropna().index
226    valid_indices = []
227
228    for i, level_point in enumerate(level_points):
229        if i == 0:
230            valid_indices.append(level_point)
231        else:
232            timedelta = level_point - level_points[i - 1]
233            if timedelta.days > lookback_period:
234                valid_indices.append(level_point)
235
236    stock_data.loc[valid_indices, level_str] = pivot_level.loc[valid_indices]
237
238return stock_data
239
240def find_double_tops_and_bottoms(self, symbol:str, stock_data:DataFrame, min_distance:int, max_distance:int, max_percentage:float) -> DataFrame:
241stock_data['Double_Top'] = None
242stock_data['Double_Bottom'] = None
243
244support_points = stock_data.dropna(subset=['Support']).index
245resistance_points = stock_data.dropna(subset=['Resistance']).index
246
247for i in range(len(resistance_points)):
248    for j in range(i + 1, len(resistance_points)):
249        timedelta = resistance_points[j] - resistance_points[i]
250        if timedelta.days < min_distance or timedelta.days > max_distance:
251            continue
252        price_pct_difference = abs(stock_data.loc[resistance_points[j], 'Resistance'] / stock_data.loc[resistance_points[i], 'Resistance'] - 1)
253        if price_pct_difference <= max_percentage:
254            lower_top_index = resistance_points[j] if stock_data.loc[resistance_points[j], 'Resistance'] < stock_data.loc[resistance_points[i], 'Resistance'] else resistance_points[i]
255            if all(stock_data.loc[resistance_points[x], symbol] <= stock_data.loc[lower_top_index, 'Resistance'] for x in range(i+1,j)):
256                stock_data.loc[lower_top_index, 'Double_Top'] = stock_data.loc[lower_top_index, 'Resistance']
257
258for i in range(len(support_points)):
259    for j in range(i + 1, len(support_points)):
260        timedelta = support_points[j] - support_points[i]
261        if timedelta.days < min_distance or timedelta.days > max_distance:
262            continue
263        price_pct_difference = abs(stock_data.loc[support_points[j], 'Support'] / stock_data.loc[support_points[i], 'Support'] - 1)
264        if price_pct_difference <= max_percentage:
265            higher_bottom_index = support_points[j] if stock_data.loc[support_points[j], 'Support'] > stock_data.loc[support_points[i], 'Support'] else support_points[i]
266            if all(stock_data.loc[support_points[x], symbol] >= stock_data.loc[higher_bottom_index, 'Support'] for x in range(i+1,j)):
267                stock_data.loc[higher_bottom_index, 'Double_Bottom'] = stock_data.loc[higher_bottom_index, 'Support']
268
269return stock_data