def kst_oscillator(close_arr, r1, r2, r3, r4, n1, n2, n3, n4): """Calculate KST Oscillator for given data. :param close_arr: close price of the bar, expect series from cudf :param r1: r1 time steps :param r2: r2 time steps :param r3: r3 time steps :param r4: r4 time steps :param n1: n1 time steps :param n2: n2 time steps :param n3: n3 time steps :param n4: n4 time steps :return: KST Oscillator in cudf.Series """ M1 = diff(close_arr, r1 - 1) N1 = shift(close_arr, r1 - 1) M2 = diff(close_arr, r2 - 1) N2 = shift(close_arr, r2 - 1) M3 = diff(close_arr, r3 - 1) N3 = shift(close_arr, r3 - 1) M4 = diff(close_arr, r4 - 1) N4 = shift(close_arr, r4 - 1) term1 = Rolling(n1, division(M1, N1)).sum() term2 = scale(Rolling(n2, division(M2, N2)).sum(), 2.0) term3 = scale(Rolling(n3, division(M3, N3)).sum(), 3.0) term4 = scale(Rolling(n4, division(M4, N4)).sum(), 4.0) KST = summation(summation(summation(term1, term2), term3), term4) return cudf.Series(KST)
def port_vortex_indicator(asset_indicator, high_arr, low_arr, close_arr, n): """Calculate the port Vortex Indicator for given data. Vortex Indicator described here: http://www.vortexindicator.com/VFX_VORTEX.PDF :param asset_indicator: the indicator of beginning of the stock :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param close_arr: close price of the bar, expect series from cudf :param n: time steps to do EWM average :return: Vortex Indicator in cudf.Series """ TR = port_true_range(asset_indicator.to_gpu_array(), high_arr.data.to_gpu_array(), low_arr.data.to_gpu_array(), close_arr.data.to_gpu_array()) VM = port_lowhigh_diff(asset_indicator.to_gpu_array(), high_arr.data.to_gpu_array(), low_arr.data.to_gpu_array()) VI = division(Rolling(n, VM).sum(), Rolling(n, TR).sum()) port_mask_nan(asset_indicator.data.to_gpu_array(), VI, 0, n - 1) return cudf.Series(VI)
def diff(in_arr, n): if n < 0: return Rolling(1, in_arr, forward_window=-n).forward_diff() elif n > 0: return Rolling(n + 1, in_arr).backward_diff() else: return in_arr
def donchian_channel(high_arr, low_arr, n): """Calculate donchian channel of given pandas data frame. :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param n: time steps :return: donchian channel in cudf.Series """ max_high = Rolling(n, high_arr).max() min_low = Rolling(n, low_arr).min() dc_l = substract(max_high, min_low) dc_l[:n - 1] = 0.0 donchian_chan = shift(dc_l, n - 1) return cudf.Series(donchian_chan)
def commodity_channel_index(high_arr, low_arr, close_arr, n): """Calculate Commodity Channel Index for given data. :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param close_arr: close price of the bar, expect series from cudf :param n: time steps :return: Commodity Channel Index in cudf.Series """ PP = average_price(high_arr.to_gpu_array(), low_arr.to_gpu_array(), close_arr.to_gpu_array()) M = Rolling(n, PP).mean() N = Rolling(n, PP).std() CCI = division(substract(PP, M), N) return cudf.Series(CCI, nan_as_null=False)
def keltner_channel(high_arr, low_arr, close_arr, n): """Calculate Keltner Channel for given data. :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param close_arr: close price of the bar, expect series from cudf :param n: time steps :return: Keltner Channel in cudf.Series """ M = ((high_arr + low_arr + close_arr) / 3.0) KelChM = cudf.Series(Rolling(n, M).mean()) U = ((4.0 * high_arr - 2.0 * low_arr + close_arr) / 3.0) KelChU = cudf.Series(Rolling(n, U).mean()) D = ((-2.0 * high_arr + 4.0 * low_arr + close_arr) / 3.0) KelChD = cudf.Series(Rolling(n, D).mean()) out = collections.namedtuple('Keltner', 'KelChM KelChU KelChD') return out(KelChM=KelChM, KelChU=KelChU, KelChD=KelChD)
def moving_average(close_arr, n): """Calculate the moving average for the given data. :param close_arr: close price of the bar, expect series from cudf :param n: time steps :return: moving average in cu.Series """ MA = Rolling(n, close_arr).mean() return cudf.Series(MA)
def port_donchian_channel(asset_indicator, high_arr, low_arr, n): """Calculate port donchian channel of given pandas data frame. :param asset_indicator: the indicator of beginning of the stock :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param n: time steps :return: donchian channel in cudf.Series """ max_high = Rolling(n, high_arr).max() port_mask_nan(asset_indicator.data.to_gpu_array(), max_high, 0, n - 1) min_low = Rolling(n, low_arr).min() port_mask_nan(asset_indicator.data.to_gpu_array(), min_low, 0, n - 1) dc_l = substract(max_high, min_low) # dc_l[:n-1] = 0.0 port_mask_zero(asset_indicator.data.to_gpu_array(), dc_l, 0, n - 1) donchian_chan = shift(dc_l, n - 1) port_mask_nan(asset_indicator.data.to_gpu_array(), donchian_chan, 0, n - 1) return cudf.Series(donchian_chan)
def port_commodity_channel_index(asset_indicator, high_arr, low_arr, close_arr, n): """Calculate port Commodity Channel Index for given data. :param asset_indicator: the indicator of beginning of the stock :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param close_arr: close price of the bar, expect series from cudf :param n: time steps :return: Commodity Channel Index in cudf.Series """ PP = average_price(high_arr.to_gpu_array(), low_arr.to_gpu_array(), close_arr.to_gpu_array()) M = Rolling(n, PP).mean() port_mask_nan(asset_indicator.to_gpu_array(), M, 0, n - 1) N = Rolling(n, PP).std() port_mask_nan(asset_indicator.to_gpu_array(), N, 0, n - 1) CCI = division(substract(PP, M), N) return cudf.Series(CCI, nan_as_null=False)
def vortex_indicator(high_arr, low_arr, close_arr, n): """Calculate the Vortex Indicator for given data. Vortex Indicator described here: http://www.vortexindicator.com/VFX_VORTEX.PDF :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param close_arr: close price of the bar, expect series from cudf :param n: time steps to do EWM average :return: Vortex Indicator in cudf.Series """ TR = true_range(high_arr.to_gpu_array(), low_arr.to_gpu_array(), close_arr.to_gpu_array()) VM = lowhigh_diff(high_arr.to_gpu_array(), low_arr.to_gpu_array()) VI = division(Rolling(n, VM).sum(), Rolling(n, TR).sum()) return cudf.Series(VI, nan_as_null=False)
def bollinger_bands(close_arr, n): """Calculate the Bollinger Bands. See https://www.investopedia.com/terms/b/bollingerbands.asp for details :param close_arr: close price of the bar, expect series from cudf :param n: time steps :return: b1 b2 """ MA = Rolling(n, close_arr).mean() MSD = Rolling(n, close_arr).std() close_arr_gpu = numba.cuda.device_array_like(close_arr.data.to_gpu_array()) close_arr_gpu[:] = close_arr.data.to_gpu_array()[:] close_arr_gpu[0:n - 1] = math.nan MSD_4 = scale(MSD, 4.0) b1 = division(MSD_4, MA) b2 = division(summation(substract(close_arr_gpu, MA), scale(MSD, 2.0)), MSD_4) out = collections.namedtuple('Bollinger', 'b1 b2') return out(b1=cudf.Series(b1), b2=cudf.Series(b2))
def port_kst_oscillator(asset_indicator, close_arr, r1, r2, r3, r4, n1, n2, n3, n4): """Calculate port KST Oscillator for given data. :param asset_indicator: the indicator of beginning of the stock :param close_arr: close price of the bar, expect series from cudf :param r1: r1 time steps :param r2: r2 time steps :param r3: r3 time steps :param r4: r4 time steps :param n1: n1 time steps :param n2: n2 time steps :param n3: n3 time steps :param n4: n4 time steps :return: KST Oscillator in cudf.Series """ M1 = diff(close_arr, r1 - 1) N1 = shift(close_arr, r1 - 1) port_mask_nan(asset_indicator.data.to_gpu_array(), M1, 0, r1 - 1) port_mask_nan(asset_indicator.data.to_gpu_array(), N1, 0, r1 - 1) M2 = diff(close_arr, r2 - 1) N2 = shift(close_arr, r2 - 1) port_mask_nan(asset_indicator.data.to_gpu_array(), M2, 0, r2 - 1) port_mask_nan(asset_indicator.data.to_gpu_array(), N2, 0, r2 - 1) M3 = diff(close_arr, r3 - 1) N3 = shift(close_arr, r3 - 1) port_mask_nan(asset_indicator.data.to_gpu_array(), M3, 0, r3 - 1) port_mask_nan(asset_indicator.data.to_gpu_array(), N3, 0, r3 - 1) M4 = diff(close_arr, r4 - 1) N4 = shift(close_arr, r4 - 1) port_mask_nan(asset_indicator.data.to_gpu_array(), M4, 0, r4 - 1) port_mask_nan(asset_indicator.data.to_gpu_array(), N4, 0, r4 - 1) term1 = Rolling(n1, division(M1, N1)).sum() port_mask_nan(asset_indicator.data.to_gpu_array(), term1, 0, n1 - 1) term2 = scale(Rolling(n2, division(M2, N2)).sum(), 2.0) port_mask_nan(asset_indicator.data.to_gpu_array(), term2, 0, n2 - 1) term3 = scale(Rolling(n3, division(M3, N3)).sum(), 3.0) port_mask_nan(asset_indicator.data.to_gpu_array(), term3, 0, n3 - 1) term4 = scale(Rolling(n4, division(M4, N4)).sum(), 4.0) port_mask_nan(asset_indicator.data.to_gpu_array(), term4, 0, n4 - 1) KST = summation(summation(summation(term1, term2), term3), term4) return cudf.Series(KST)
def on_balance_volume(close_arr, volume_arr, n): """Calculate On-Balance Volume for given data. :param close_arr: close price of the bar, expect series from cudf :param volume_arr: volume the bar, expect series from cudf :param n: time steps :return: On-Balance Volume in cudf.Series """ OBV = onbalance_volume(close_arr.to_gpu_array(), volume_arr.to_gpu_array()) OBV_ma = Rolling(n, OBV).mean() return cudf.Series(OBV_ma, nan_as_null=False)
def port_moving_average(asset_indicator, close_arr, n): """Calculate the port moving average for the given data. :param asset_indicator: the indicator of beginning of the stock :param close_arr: close price of the bar, expect series from cudf :param n: time steps :return: expoential weighted moving average in cu.Series """ MA = Rolling(n, close_arr).mean() port_mask_nan(asset_indicator.data.to_gpu_array(), MA, 0, n - 1) return cudf.Series(MA)
def port_keltner_channel(asset_indicator, high_arr, low_arr, close_arr, n): """Calculate port Keltner Channel for given data. :param asset_indicator: the indicator of beginning of the stock :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param close_arr: close price of the bar, expect series from cudf :param n: time steps :return: Keltner Channel in cudf.Series """ M = ((high_arr + low_arr + close_arr) / 3.0) KelChM = Rolling(n, M).mean() port_mask_nan(asset_indicator.data.to_gpu_array(), KelChM, 0, n - 1) U = ((4.0 * high_arr - 2.0 * low_arr + close_arr) / 3.0) KelChU = Rolling(n, U).mean() port_mask_nan(asset_indicator.data.to_gpu_array(), KelChU, 0, n - 1) D = ((-2.0 * high_arr + 4.0 * low_arr + close_arr) / 3.0) KelChD = Rolling(n, D).mean() port_mask_nan(asset_indicator.data.to_gpu_array(), KelChD, 0, n - 1) out = collections.namedtuple('Keltner', 'KelChM KelChU KelChD') return out(KelChM=cudf.Series(KelChM), KelChU=cudf.Series(KelChU), KelChD=cudf.Series(KelChD))
def port_bollinger_bands(asset_indicator, close_arr, n): """Calculate the port Bollinger Bands. See https://www.investopedia.com/terms/b/bollingerbands.asp for details :param asset_indicator: the indicator of beginning of the stock :param close_arr: close price of the bar, expect series from cudf :param n: time steps :return: b1 b2 """ MA = Rolling(n, close_arr).mean() port_mask_nan(asset_indicator.to_gpu_array(), MA, 0, n - 1) MSD = Rolling(n, close_arr).std() port_mask_nan(asset_indicator.to_gpu_array(), MSD, 0, n - 1) close_arr_gpu = numba.cuda.device_array_like(close_arr.to_gpu_array()) close_arr_gpu[:] = close_arr.to_gpu_array()[:] close_arr_gpu[0:n - 1] = math.nan MSD_4 = scale(MSD, 4.0) b1 = division(MSD_4, MA) b2 = division(summation(substract(close_arr_gpu, MA), scale(MSD, 2.0)), MSD_4) out = collections.namedtuple('Bollinger', 'b1 b2') return out(b1=cudf.Series(b1, nan_as_null=False), b2=cudf.Series(b2, nan_as_null=False))
def port_on_balance_volume(asset_indicator, close_arr, volume_arr, n): """Calculate port On-Balance Volume for given data. :param asset_indicator: the indicator of beginning of the stock :param close_arr: close price of the bar, expect series from cudf :param volume_arr: volume the bar, expect series from cudf :param n: time steps :return: On-Balance Volume in cudf.Series """ OBV = port_onbalance_volume(asset_indicator.data.to_gpu_array(), close_arr.data.to_gpu_array(), volume_arr.data.to_gpu_array()) OBV_ma = Rolling(n, OBV).mean() port_mask_nan(asset_indicator.data.to_gpu_array(), OBV_ma, 0, n - 1) return cudf.Series(OBV_ma)
def mass_index(high_arr, low_arr, n1, n2): """Calculate the Mass Index for given data. :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param n1: n1 time steps :param n1: n2 time steps :return: Mass Index in cudf.Series """ Range = high_arr - low_arr EX1 = Ewm(n1, Range).mean() EX2 = Ewm(n1, EX1).mean() Mass = division(EX1, EX2) MassI = Rolling(n2, Mass).sum() return cudf.Series(MassI)
def money_flow_index(high_arr, low_arr, close_arr, volume_arr, n): """Calculate Money Flow Index and Ratio for given data. :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param close_arr: close price of the bar, expect series from cudf :param volume_arr: volume the bar, expect series from cudf :param n: time steps :return: Money Flow Index in cudf.Series """ PP = average_price(high_arr.to_gpu_array(), low_arr.to_gpu_array(), close_arr.to_gpu_array()) PosMF = money_flow(PP, volume_arr.to_gpu_array()) MFR = division(PosMF, (multiply(PP, volume_arr.to_gpu_array()))) # TotMF MFI = Rolling(n, MFR).mean() return cudf.Series(MFI, nan_as_null=False)
def port_mass_index(asset_indicator, high_arr, low_arr, n1, n2): """Calculate the port Mass Index for given data. :param asset_indicator: the indicator of beginning of the stock :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param n1: n1 time steps :param n1: n2 time steps :return: Mass Index in cudf.Series """ Range = high_arr - low_arr EX1 = PEwm(n1, Range, asset_indicator).mean() EX2 = PEwm(n1, EX1, asset_indicator).mean() Mass = division(EX1, EX2) MassI = Rolling(n2, Mass).sum() port_mask_nan(asset_indicator.data.to_gpu_array(), MassI, 0, n2 - 1) return cudf.Series(MassI)
def ease_of_movement(high_arr, low_arr, volume_arr, n): """Calculate Ease of Movement for given data. :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param volume_arr: volume the bar, expect series from cudf :param n: time steps :return: Ease of Movement in cudf.Series """ high_arr_gpu = high_arr.data.to_gpu_array() low_arr_gpu = low_arr.data.to_gpu_array() EoM = division( multiply(summation(diff(high_arr_gpu, 1), diff(low_arr_gpu, 1)), substract(high_arr_gpu, low_arr_gpu)), scale(volume_arr.data.to_gpu_array(), 2.0)) Eom_ma = Rolling(n, EoM).mean() return cudf.Series(Eom_ma)
def port_money_flow_index(asset_indicator, high_arr, low_arr, close_arr, volume_arr, n): """Calculate port Money Flow Index and Ratio for given data. :param asset_indicator: the indicator of beginning of the stock :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param close_arr: close price of the bar, expect series from cudf :param volume_arr: volume the bar, expect series from cudf :param n: time steps :return: Money Flow Index in cudf.Series """ PP = average_price(high_arr.to_gpu_array(), low_arr.to_gpu_array(), close_arr.to_gpu_array()) PosMF = port_money_flow(asset_indicator.to_gpu_array(), PP, volume_arr.to_gpu_array()) MFR = division(PosMF, (multiply(PP, volume_arr.to_gpu_array()))) # TotMF MFI = Rolling(n, MFR).mean() port_mask_nan(asset_indicator.to_gpu_array(), MFI, 0, n - 1) return cudf.Series(MFI, nan_as_null=False)
def port_ease_of_movement(asset_indicator, high_arr, low_arr, volume_arr, n): """Calculate port Ease of Movement for given data. :param asset_indicator: the indicator of beginning of the stock :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param volume_arr: volume the bar, expect series from cudf :param n: time steps :return: Ease of Movement in cudf.Series """ high_arr_gpu = high_arr.data.to_gpu_array() low_arr_gpu = low_arr.data.to_gpu_array() EoM = division( multiply(summation(diff(high_arr_gpu, 1), diff(low_arr_gpu, 1)), substract(high_arr_gpu, low_arr_gpu)), scale(volume_arr.data.to_gpu_array(), 2.0)) port_mask_nan(asset_indicator.data.to_gpu_array(), EoM, 0, 1) Eom_ma = Rolling(n, EoM).mean() port_mask_nan(asset_indicator.data.to_gpu_array(), Eom_ma, 0, n - 1) return cudf.Series(Eom_ma)
def ultimate_oscillator(high_arr, low_arr, close_arr): """Calculate Ultimate Oscillator for given data. :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param close_arr: close price of the bar, expect series from cudf :return: Ultimate Oscillator in cudf.Series """ TR_l, BP_l = ultimate_osc(high_arr.to_gpu_array(), low_arr.to_gpu_array(), close_arr.to_gpu_array()) term1 = division(scale(Rolling(7, BP_l).sum(), 4.0), Rolling(7, TR_l).sum()) term2 = division(scale(Rolling(14, BP_l).sum(), 2.0), Rolling(14, TR_l).sum()) term3 = division(Rolling(28, BP_l).sum(), Rolling(28, TR_l).sum()) UltO = summation(summation(term1, term2), term3) return cudf.Series(UltO, nan_as_null=False)
def port_ultimate_oscillator(asset_indicator, high_arr, low_arr, close_arr): """Calculate port Ultimate Oscillator for given data. :param asset_indicator: the indicator of beginning of the stock :param high_arr: high price of the bar, expect series from cudf :param low_arr: low price of the bar, expect series from cudf :param close_arr: close price of the bar, expect series from cudf :return: Ultimate Oscillator in cudf.Series """ TR_l, BP_l = port_ultimate_osc(asset_indicator.data.to_gpu_array(), high_arr.data.to_gpu_array(), low_arr.data.to_gpu_array(), close_arr.data.to_gpu_array()) term1 = division(scale(Rolling(7, BP_l).sum(), 4.0), Rolling(7, TR_l).sum()) term2 = division(scale(Rolling(14, BP_l).sum(), 2.0), Rolling(14, TR_l).sum()) term3 = division(Rolling(28, BP_l).sum(), Rolling(28, TR_l).sum()) port_mask_nan(asset_indicator.data.to_gpu_array(), term1, 0, 6) port_mask_nan(asset_indicator.data.to_gpu_array(), term2, 0, 13) port_mask_nan(asset_indicator.data.to_gpu_array(), term3, 0, 27) UltO = summation(summation(term1, term2), term3) return cudf.Series(UltO)