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)