Added a function to specifically get the most recent value of ohlc, rather than generating the full slice first. ~12% speed improvement

Author: ChadThackray

backtesting/_util.py

@@ -216,6 +216,11 @@ def __get_array(self, key) -> _Array:
             arr = self.__cache[key] = cast(_Array, self.__arrays[key][:self.__len])
         return arr
 
+    def current_value(self, key: str):
+        if self.__len <= 0:
+            raise IndexError("No data available")
+        return self.__arrays[key][self.__len - 1]
+
     @property
     def Open(self) -> _Array:
         return self.__get_array('Open')

backtesting/backtesting.py

@@ -870,7 +870,9 @@ def next(self):
 
     def _process_orders(self):
         data = self._data
-        open, high, low = data.Open[-1], data.High[-1], data.Low[-1]
+        open_price = data.current_value("Open")
+        high_price = data.current_value("High")
+        low_price = data.current_value("Low")
         reprocess_orders = False
 
         # Process orders
@@ -883,7 +885,9 @@ def _process_orders(self):
             # Check if stop condition was hit
             stop_price = order.stop
             if stop_price:
-                is_stop_hit = ((high >= stop_price) if order.is_long else (low <= stop_price))
+                is_stop_hit = (
+                    high_price >= stop_price if order.is_long else low_price <= stop_price
+                )
                 if not is_stop_hit:
                     continue
 
@@ -894,7 +898,9 @@ def _process_orders(self):
             # Determine purchase price.
             # Check if limit order can be filled.
             if order.limit:
-                is_limit_hit = low <= order.limit if order.is_long else high >= order.limit
+                is_limit_hit = (
+                    low_price <= order.limit if order.is_long else high_price >= order.limit
+                )
                 # When stop and limit are hit within the same bar, we pessimistically
                 # assume limit was hit before the stop (i.e. "before it counts")
                 is_limit_hit_before_stop = (is_limit_hit and
@@ -905,14 +911,20 @@ def _process_orders(self):
                     continue
 
                 # stop_price, if set, was hit within this bar
-                price = (min(stop_price or open, order.limit)
-                         if order.is_long else
-                         max(stop_price or open, order.limit))
+                price = (
+                    min(stop_price or open_price, order.limit)
+                    if order.is_long
+                    else max(stop_price or open_price, order.limit)
+                )
             else:
                 # Market-if-touched / market order
                 # Contingent orders always on next open
                 prev_close = data.Close[-2]
-                price = prev_close if self._trade_on_close and not order.is_contingent else open
+                price = (
+                    prev_close
+                    if self._trade_on_close and not order.is_contingent
+                    else open_price
+                )
                 if stop_price:
                     price = max(price, stop_price) if order.is_long else min(price, stop_price)
 
@@ -1018,12 +1030,28 @@ def _process_orders(self):
                         reprocess_orders = True
                     # Order.stop and TP hit within the same bar, but SL wasn't. This case
                     # is not ambiguous, because stop and TP go in the same price direction.
-                    elif stop_price and not order.limit and order.tp and (
-                            (order.is_long and order.tp <= high and (order.sl or -np.inf) < low) or
-                            (order.is_short and order.tp >= low and (order.sl or np.inf) > high)):
+                    elif (
+                        stop_price
+                        and not order.limit
+                        and order.tp
+                        and (
+                            (
+                                order.is_long
+                                and order.tp <= high_price
+                                and (order.sl or -np.inf) < low_price
+                            )
+                            or (
+                                order.is_short
+                                and order.tp >= low_price
+                                and (order.sl or np.inf) > high_price
+                            )
+                        )
+                    ):
                         reprocess_orders = True
-                    elif (low <= (order.sl or -np.inf) <= high or
-                          low <= (order.tp or -np.inf) <= high):
+                    elif (
+                        low_price <= (order.sl or -np.inf) <= high_price
+                        or low_price <= (order.tp or -np.inf) <= high_price
+                    ):
                         warnings.warn(
                             f"({data.index[-1]}) A contingent SL/TP order would execute in the "
                             "same bar its parent stop/limit order was turned into a trade. "