def ma_nb(a: tp.Array2d, window: int, ewm: bool, adjust: bool = False) -> tp.Array2d: """Compute simple or exponential moving average (`ewm=True`).""" if ewm: return generic_nb.ewm_mean_nb(a, window, minp=window, adjust=adjust) return generic_nb.rolling_mean_nb(a, window, minp=window)
def future_mean_apply_nb(close, window, ewm, wait=1, adjust=False): """Get the mean of the next period.""" if ewm: out = generic_nb.ewm_mean_nb(close[::-1], window, minp=window, adjust=adjust)[::-1] else: out = generic_nb.rolling_mean_nb(close[::-1], window, minp=window)[::-1] if wait > 0: return generic_nb.bshift_nb(out, wait) return out
def stoch_apply_nb(close_ts, high_ts, low_ts, k_window, d_window, d_ewm, cache_dict): """Apply function for `vectorbt.indicators.basic.Stochastic`.""" h = hash(k_window) roll_min, roll_max = cache_dict[h] percent_k = 100 * (close_ts - roll_min) / (roll_max - roll_min) if d_ewm: percent_d = generic_nb.ewm_mean_nb(percent_k, d_window) else: percent_d = generic_nb.rolling_mean_nb(percent_k, d_window) return percent_k, percent_d
def ma_caching_nb(ts, windows, ewms): """Caching function for `vectorbt.indicators.basic.MA`.""" cache_dict = dict() for i in range(windows.shape[0]): h = hash((windows[i], ewms[i])) if h not in cache_dict: if ewms[i]: ma = generic_nb.ewm_mean_nb(ts, windows[i]) else: ma = generic_nb.rolling_mean_nb(ts, windows[i]) cache_dict[h] = ma return cache_dict
def rsi_caching_nb(ts, windows, ewms): """Caching function for `vectorbt.indicators.basic.RSI`.""" delta = generic_nb.diff_nb(ts)[1:, :] # otherwise ewma will be all NaN up, down = delta.copy(), delta.copy() up = generic_nb.set_by_mask_nb(up, up < 0, 0) down = np.abs(generic_nb.set_by_mask_nb(down, down > 0, 0)) # Cache cache_dict = dict() for i in range(windows.shape[0]): h = hash((windows[i], ewms[i])) if h not in cache_dict: if ewms[i]: roll_up = generic_nb.ewm_mean_nb(up, windows[i]) roll_down = generic_nb.ewm_mean_nb(down, windows[i]) else: roll_up = generic_nb.rolling_mean_nb(up, windows[i]) roll_down = generic_nb.rolling_mean_nb(down, windows[i]) roll_up = generic_nb.prepend_nb(roll_up, 1, np.nan) # bring to old shape roll_down = generic_nb.prepend_nb(roll_down, 1, np.nan) cache_dict[h] = roll_up, roll_down return cache_dict
def macd_apply_nb(ts, fast_window, slow_window, signal_window, macd_ewm, signal_ewm, cache_dict): """Apply function for `vectorbt.indicators.basic.MACD`.""" fast_h = hash((fast_window, macd_ewm)) slow_h = hash((slow_window, macd_ewm)) fast_ma = cache_dict[fast_h] slow_ma = cache_dict[slow_h] macd_ts = fast_ma - slow_ma if signal_ewm: signal_ts = generic_nb.ewm_mean_nb(macd_ts, signal_window) else: signal_ts = generic_nb.rolling_mean_nb(macd_ts, signal_window) return macd_ts, signal_ts
def future_mean_apply_nb(close: tp.Array2d, window: int, ewm: bool, wait: int = 1, adjust: bool = False) -> tp.Array2d: """Get the mean of the next period.""" if ewm: out = generic_nb.ewm_mean_nb(close[::-1], window, minp=window, adjust=adjust)[::-1] else: out = generic_nb.rolling_mean_nb(close[::-1], window, minp=window)[::-1] if wait > 0: return generic_nb.bshift_nb(out, wait) return out
def atr_caching_nb(close_ts, high_ts, low_ts, windows, ewms): """Caching function for `vectorbt.indicators.basic.ATR`.""" # Calculate TR here instead of re-calculating it for each param in atr_apply_nb tr0 = high_ts - low_ts tr1 = np.abs(high_ts - generic_nb.fshift_nb(close_ts, 1)) tr2 = np.abs(low_ts - generic_nb.fshift_nb(close_ts, 1)) tr = nanmax_cube_nb(np.stack((tr0, tr1, tr2))) cache_dict = dict() for i in range(windows.shape[0]): h = hash((windows[i], ewms[i])) if h not in cache_dict: if ewms[i]: atr = generic_nb.ewm_mean_nb(tr, windows[i]) else: atr = generic_nb.rolling_mean_nb(tr, windows[i]) cache_dict[h] = atr return tr, cache_dict
def ma_nb(a, window, ewm): """Compute simple or exponential moving average (`ewm=True`).""" if ewm: return generic_nb.ewm_mean_nb(a, window, minp=window, adjust=False) return generic_nb.rolling_mean_nb(a, window, minp=window)