Пример #1
0
    def RSI_n_sf(N, data, step=1, filtering=False):
        # from the RSI indicator
        sub_data = down_sample(data, step) if filtering else data[::step]
        t_subdata = range(0, len(data), step)

        variations = np.diff(sub_data)
        #variations = np.diff(sub_data) / sub_data[:-1]

        # h = np.array(list(map(lambda x: max(x,0), variations)))
        # b = np.array(list(map(lambda x: abs(min(x,0)), variations)))

        # or that to avoid zeros
        h = np.array(list(map(lambda x: max(x, 0.000001), variations)))
        b = np.array(list(map(lambda x: abs(min(x, -0.000001)), variations)))

        # exp or linear
        # hn = np.interp(range(len(data)), t_subdata[1:], MMexp_n(N, h))
        # bn = np.interp(range(len(data)), t_subdata[1:], MMexp_n(N, b))

        hn = np.interp(range(len(data)), t_subdata[1:], MM_n(N, h))
        bn = np.interp(range(len(data)), t_subdata[1:], MM_n(N, b))

        # prefer to return in normalized 0..1
        rsi = hn / (hn + bn)
        return rsi
Пример #2
0
    def RSI_n_sf(N, data, step=1, filtering=False):
        """ 
        Calcule le RSI sur N periodes en prenant un echantillon tous les step avec ou sans filtrage prealable
        Retourne un array de la même taille que data. Lorsque step > 1, les valeurs sont interpolees lineairement.
        """
        # have a difference with others algo, it seems doubling N make the deals... but what's the problem
        sub_data = down_sample(data, step) if filtering else data [::step]
        t_subdata = range(0,len(data),step)

        variations = np.diff(sub_data)
        #variations = np.diff(sub_data) / sub_data[:-1]

        # h = np.array(list(map(lambda x: max(x,0), variations)))
        # b = np.array(list(map(lambda x: abs(min(x,0)), variations)))

        # or that to avoid zeros
        h = np.array(list(map(lambda x: max(x,0.000000001), variations)))
        b = np.array(list(map(lambda x: abs(min(x,-0.000000001)), variations)))

        # exp or linear
        # hn = np.interp(range(len(data)), t_subdata[1:], MMexp_n(N, h))
        # bn = np.interp(range(len(data)), t_subdata[1:], MMexp_n(N, b))

        hn = np.interp(range(len(data)), t_subdata[1:], MM_n(N, h))
        bn = np.interp(range(len(data)), t_subdata[1:], MM_n(N, b))

        # prefer to return in normalized 0..1
        rsi = hn/(hn+bn)
        return rsi
Пример #3
0
    def Stochastic_sf(N, data, N_D=3, step=1, filtering=False):
        """ 
        Calcul des stochastiques.
        N est le nombre de periodes a observer pour repérer le min et le max du cours.
        N_D est le nombre d'echantillons de K a utiliser pour le calcul de D
        step permet de ne selectionner qu'un echantillon sur step dans data.
        filtering permet de filtrer ou non les donnees avant d'appliquer la selection.

        Retourne les stochastiques K, D interpolees lineairement ; meme taille que data.
        """
        sub_data = down_sample(data, step) if filtering else data[::step]

        K = np.zeros(len(sub_data))
        t_subdata = range(0, len(data), step)

        for (j, d) in enumerate(sub_data):
            i = min(j, N)
            highest = max(sub_data[j - i:j + 1])
            lowest = min(sub_data[j - i:j + 1])

            if highest == lowest:
                highest += 0.000000001

            K[j] = (d - lowest) / (highest - lowest)  # +epsilon to avoid 0

        D = MM_n(N_D, K)

        return np.interp(range(len(data)), t_subdata,
                         K), np.interp(range(len(data)), t_subdata, D)
Пример #4
0
    def RSI_n(N, data):
        # from the RSI indicator
        variations = np.diff(data)
        #variations = np.diff(data) / data[:-1]

        # h = np.array(list(map(lambda x: max(x,0), variations)))
        # b = np.array(list(map(lambda x: abs(min(x,0)), variations)))

        # or that to avoid zeros
        h = np.array(list(map(lambda x: max(x, 0.000001), variations)))
        b = np.array(list(map(lambda x: abs(min(x, -0.000001)), variations)))

        # exp or linear
        hn = MM_n(N, h)  # MMexp_n(N, h)
        bn = MM_n(N, b)  # MMexp_n(N, b

        # prefer to return in normalized 0..1
        rsi = hn / (hn + bn)
        return rsi
Пример #5
0
    def SMA_n_sf(N, data, step=1, filtering=False):
        """ 
        Calcule une SMA sur N periodes en prenant un echantillon tous les step avec ou sans filtrage prealable
        Retourne un array de la même taille que data. Lorsque step > 1, les valeurs sont interpolees lineairement.
        """
        sub_data = down_sample(data, step) if filtering else data[::step]
        t_subdata = range(0, len(data), step)

        sma = MM_n(N, data)

        return sma
Пример #6
0
    def VWMA_n_sf(N, prices, volumes, step=1, filtering=False):
        """ 
        Calcule une VWMA sur N periodes en prenant un echantillon tous les step avec ou sans filtrage prealable
        Retourne un array de la meme taille que data. Lorsque step > 1, les valeurs sont interpolees lineairement.
        """
        p_sub_data = down_sample(
            prices, step) if filtering else np.array(prices)[::step]
        v_sub_data = down_sample(
            volumes, step) if filtering else np.array(volumes)[::step]
        t_subdata = range(0, len(prices), step)

        # cannot deal with zero volume, then set it to 1 will have no effect on the result, juste give a price
        for i, v in enumerate(v_sub_data):
            if v <= 0:
                v_sub_data[i] = 1.0

        pvs = MM_n(N, p_sub_data * v_sub_data)
        vs = MM_n(N, v_sub_data)

        return pvs / vs
Пример #7
0
    def WMA_n_sf(N, prices, step=1, filtering=False):
        """ 
        Calcule une WMA sur N periodes en prenant un echantillon tous les step avec ou sans filtrage prealable
        Retourne un array de la même taille que data. Lorsque step > 1, les valeurs sont interpolees lineairement.
        """
        sub_data = down_sample(prices, step) if filtering else np.array(prices) [::step]
        t_subdata = range(0,len(prices),step)

        weights = np.array([x for x in range(1, len(sub_data)+1)])
        wma = MM_n(N, sub_data*weights) / weights

        return wma
Пример #8
0
    def RSI_n(N, data):
        """ 
        Calcule le RSI sur N periodes en prenant un echantillon tous les step avec ou sans filtrage prealable
        Retourne un array de la même taille que data. Lorsque step > 1, les valeurs sont interpolees lineairement.
        """
        variations = np.diff(data)
        #variations = np.diff(data) / data[:-1]

        # h = np.array(list(map(lambda x: max(x,0), variations)))
        # b = np.array(list(map(lambda x: abs(min(x,0)), variations)))

        # or that to avoid zeros
        h = np.array(list(map(lambda x: max(x,0.000000001), variations)))
        b = np.array(list(map(lambda x: abs(min(x,-0.000000001)), variations)))

        # exp or linear
        hn = MM_n(N, h)  # MMexp_n(N, h)
        bn = MM_n(N, b)  # MMexp_n(N, b)

        # prefer to return in normalized 0..1
        rsi = hn/(hn+bn)
        return rsi
Пример #9
0
    def BB(N, data):
        mm = MM_n(N, data)
        up_bol = copy.deepcopy(mm)
        bottom_bol = copy.deepcopy(mm)

        for (j, d) in enumerate(data):
            i = min(j, N)
            sample = data[j - i:j + 1]
            sigma = 0 if j == 0 else np.sqrt(stat.variance(sample, up_bol[j]))
            up_bol[j] = up_bol[j] + 2 * sigma
            bottom_bol[j] = bottom_bol[j] - 2 * sigma

        return (bottom_bol, mm, up_bol)
Пример #10
0
    def StochRSI(N, rsi, N_D=3):
        # from the Stochastic indicator
        K = np.zeros(len(rsi))

        for (j, d) in enumerate(rsi):
            i = min(j, N)
            highest = max(rsi[j - i:j + 1])
            lowest = min(rsi[j - i:j + 1])

            if highest == lowest:
                highest += 0.000000001

            K[j] = (d - lowest) / (highest - lowest)  # +epsilon to avoid 0

        D = MM_n(N_D, K)
        return K, D
Пример #11
0
    def Stochastic(N, data, N_D=3):
        K = np.zeros(len(data))

        for (j, d) in enumerate(data):
            i = min(j, N)
            highest = max(data[j - i:j + 1])
            lowest = min(data[j - i:j + 1])

            if highest == lowest:
                highest += 0.000000001

            K[j] = (d - lowest) / (highest - lowest)  # +epsilon to avoid 0

        D = MM_n(N_D, K)

        return (K, D)
Пример #12
0
    def BB_sf(N, data, step=1, filtering=False):
        """
      Calcul des bandes de Bollinger
      N est le nombre de periodes à observer pour calculer la MM et sigma
      step permet de selectionner un echantillon tout les steps, avec filtrage ou non
      Retourne 3 courbes : Bollinger bas ; MM_N ; Bollinger haut, interpolees linéairement
      """
        sub_data = down_sample(data, step) if filtering else data[::step]
        t_subdata = range(0, len(data), step)

        mm = MM_n(N, sub_data)
        up_bol = copy.deepcopy(mm)
        bottom_bol = copy.deepcopy(mm)

        for (j, d) in enumerate(sub_data):
            i = min(j, N)
            sample = sub_data[j - i:j + 1]
            sigma = 0 if j == 0 else np.sqrt(stat.variance(sample, up_bol[j]))
            up_bol[j] = up_bol[j] + 2 * sigma
            bottom_bol[j] = bottom_bol[j] - 2 * sigma

        return (np.interp(range(len(data)), t_subdata, bottom_bol),
                np.interp(range(len(data)), t_subdata,
                          mm), np.interp(range(len(data)), t_subdata, up_bol))
Пример #13
0
    def HMA_n_sf(N, data, step=1, filtering=False):
        """ 
        Calcule un HMA sur N periodes en prenant un echantillon tous les step avec ou sans filtrage prealable
        Retourne un array de la même taille que data. Lorsque step > 1, les valeurs sont interpolees lineairement.
        """
        sub_data = down_sample(data, step) if filtering else data [::step]
        t_subdata = range(0,len(data),step)

        N_2 = int(N / 2)
        N_sqrt = int(math.sqrt(N))

        weights = np.array([x for x in range(1, len(sub_data)+1)])

        # 1) calculate a WMA with period n / 2 and multiply it by 2
        hma12 = 2 * MM_n(N_2, sub_data*weights) / MM_n(N_2, weights)

        # 2) calculate a WMA for period n and subtract if from step 1
        hma12 = hma12 - (MM_n(N, sub_data*weights) / MM_n(N, weights))

        # 3) calculate a WMA with period sqrt(n) using the data from step 2
        hma = (MM_n(N_sqrt, hma12*weights) / MM_n(N_sqrt, weights))

        return hma
Пример #14
0
    def WMA_n(N, prices):
        weights = np.array([x for x in range(1, len(prices) + 1)])
        wma = MM_n(N, prices * weights) / weights

        return wma