Example #1
0
def score(sprice, svolume):
    ''' 对当日进行评分
        按照价格变化和成交量变化打分
        价格上升    量上升  2分
                    否则    1分
        价格下降    量上升  -2分
                    否则    -1分
        价格平      0分
    '''
    fprice = np.sign(subd(sprice))
    fvolume = np.choose(subd(svolume) > 0, [1, 2])
    return fprice * fvolume
Example #2
0
def score(sprice,svolume):
    ''' 对当日进行评分
        按照价格变化和成交量变化打分
        价格上升    量上升  2分
                    否则    1分
        价格下降    量上升  -2分
                    否则    -1分
        价格平      0分
    '''
    fprice = np.sign(subd(sprice))
    fvolume = np.choose(subd(svolume) > 0,[1,2])
    return fprice * fvolume
Example #3
0
def dm(shigh,slow):
    ''' 动向计算
        通达信公式
            HD :=HIGH-REF(HIGH,1);
            LD :=REF(LOW,1)-LOW;
            DMP:=EXPMEMA(IF(HD>0&&HD>LD,HD,0),N);
            DMM:=EXPMEMA(IF(LD>0&&LD>HD,LD,0),N);
            这里取消了N的EXP
    '''
    tpdm = subd(shigh)
    tndm = -subd(slow)
    pdm = np.select([gand(tpdm>0,tpdm>tndm)],[tpdm],default=0)
    ndm = np.select([gand(tndm>0,tndm>tpdm)],[tndm],default=0)
    return pdm,ndm
Example #4
0
def dm(shigh, slow):
    ''' 动向计算
        通达信公式
            HD :=HIGH-REF(HIGH,1);
            LD :=REF(LOW,1)-LOW;
            DMP:=EXPMEMA(IF(HD>0&&HD>LD,HD,0),N);
            DMM:=EXPMEMA(IF(LD>0&&LD>HD,LD,0),N);
            这里取消了N的EXP
    '''
    tpdm = subd(shigh)
    tndm = -subd(slow)
    pdm = np.select([gand(tpdm > 0, tpdm > tndm)], [tpdm], default=0)
    ndm = np.select([gand(tndm > 0, tndm > tpdm)], [tndm], default=0)
    return pdm, ndm
Example #5
0
def semv(shigh,slow,sweight,length=13):#标准化后的emv算法,length为均线长度,sweight即为成交量(权重)
    '''
    标准化后的波动难易度
        mid = (max + min)/2
        mid_rate = (mid(n) - mid(n-1)) / mid(n) * BASE
        svolume_rate = svolume(n)/MA(svolume,length) * BASE
        wave_rate = (max-min)/ma(max-min,length) * BASE
        box_rate = svolume_rate / wave_rate
        semv = mid_rate / box_rate    
    '''
    assert len(shigh) == len(sweight) == len(sweight)
    if(len(shigh)<length):
        return np.zeros_like(shigh)
    wma = np.roll(ma(sweight,length),1)
    dma = np.roll(ma(shigh - slow,length),1)
    mid = (shigh + slow)/2
    mid_diff = subd(mid,1)
    mid_rate = np.cast['int64'](mid_diff) * BASE * BASE / mid
    swb = np.cast['int64'](sweight) * BASE
    swr = np.where(wma,swb/wma,swb*10)
    ssb = (shigh-slow)*BASE
    wr = np.where(dma,ssb/dma,ssb*10)   #dma必然大于等于0,等于0时相当于乘10
    rev = np.where(swr>0,mid_rate * wr/swr,mid_rate*wr*10)
    rev[:length] = 0
    return np.cast['int32'](rev)        
Example #6
0
def prepare_common_old(sdata,ref):
    for s in sdata:
        #print s.code
        s.ref = ref
        c = s.transaction[CLOSE]
        v = s.transaction[VOLUME]
        s.ma10 = ma(c,10)
        s.ma20 = ma(c,20)
        s.ma60 = ma(c,60)
        s.ma120 = ma(c,120)
        s.t120 = strend(s.ma120) > 0
        s.t60 = strend(s.ma60) > 0
        s.t20 = strend(s.ma20) > 0
        s.above = gand(s.ma10>=s.ma20,s.ma20>=s.ma60,s.ma60>=s.ma120)
        #将golden和above分开
        s.golden = gand(s.g20 >= s.g60+1000,s.g60 >= s.g120+1000,s.g20>=3000,s.g20<=8000)
        s.thumb = gand(s.g20 >= s.g60,s.g60 >= s.g120,s.g120 >= s.g250,s.g20>=3000,s.g20<=8000)
        s.magic = gand(s.g5>s.g60,s.g20 >= s.g60,s.g60 >= s.g120,s.g120 >= s.g250,s.g20<8000)
        s.svap_ma_67 = svap_ma(v,c,67)
        s.svap_ma_67_2 = svap_ma(v,c,67,weight=2)        
        #s.vap_ma_67 = vap_pre(v,c,67)
        s.ks = subd(c) * BASE / rollx(c)
        try:    #计算
            s.silver = catalog_signal_cs(s.c60,csilver)
        except:
            s.silver = cached_zeros(len(c))
Example #7
0
def semv(shigh,
         slow,
         sweight,
         length=13):  #标准化后的emv算法,length为均线长度,sweight即为成交量(权重)
    '''
    标准化后的波动难易度
        mid = (max + min)/2
        mid_rate = (mid(n) - mid(n-1)) / mid(n) * BASE
        svolume_rate = svolume(n)/MA(svolume,length) * BASE
        wave_rate = (max-min)/ma(max-min,length) * BASE
        box_rate = svolume_rate / wave_rate
        semv = mid_rate / box_rate    
    '''
    assert len(shigh) == len(sweight) == len(sweight)
    if (len(shigh) < length):
        return np.zeros_like(shigh)
    wma = np.roll(ma(sweight, length), 1)
    dma = np.roll(ma(shigh - slow, length), 1)
    mid = (shigh + slow) / 2
    mid_diff = subd(mid, 1)
    mid_rate = np.cast['int64'](mid_diff) * BASE * BASE / mid
    swb = np.cast['int64'](sweight) * BASE
    swr = np.where(wma, swb / wma, swb * 10)
    ssb = (shigh - slow) * BASE
    wr = np.where(dma, ssb / dma, ssb * 10)  #dma必然大于等于0,等于0时相当于乘10
    rev = np.where(swr > 0, mid_rate * wr / swr, mid_rate * wr * 10)
    rev[:length] = 0
    return np.cast['int32'](rev)
Example #8
0
def efficient_rate(source, covered=10):
    ''' 效率函数. 来源: smarter trading (略有不同,书中效率值为abs值,而此函数以负表示下降效率)
        根据单一source计算(存在其他方式的效率计算方法,但在此如此计算)
        先计算n日内每日波动幅度amplitude = abs(source[i]-source[i-1]),然后根据n求和为s_amplitude
        然后计算n日总波幅t_amplitude = source[i]-source[i-n]
        当日效率系数 = t_amplitude / s_amplitude
        第covered+1个数据(下标为covered)开始有效,之前的全部置0
        效率值有正有负,为负表明是下降效率
    '''
    assert covered > 0
    if (len(source) <= covered):
        return np.zeros_like(source)
    sdiff = np.abs(subd(source))
    ssum = msum(sdiff, covered)
    sdiffc = subd(source, covered)
    rev = sdiffc * BASE / ssum
    rev[:covered] = 0
    return rev
Example #9
0
def efficient_rate(source,covered=10):
    ''' 效率函数. 来源: smarter trading (略有不同,书中效率值为abs值,而此函数以负表示下降效率)
        根据单一source计算(存在其他方式的效率计算方法,但在此如此计算)
        先计算n日内每日波动幅度amplitude = abs(source[i]-source[i-1]),然后根据n求和为s_amplitude
        然后计算n日总波幅t_amplitude = source[i]-source[i-n]
        当日效率系数 = t_amplitude / s_amplitude
        第covered+1个数据(下标为covered)开始有效,之前的全部置0
        效率值有正有负,为负表明是下降效率
    '''
    assert covered > 0
    if(len(source) <= covered):
        return np.zeros_like(source)
    sdiff = np.abs(subd(source))
    ssum = msum(sdiff,covered)
    sdiffc = subd(source,covered)
    rev = sdiffc * BASE / ssum
    rev[:covered] = 0
    return rev
Example #10
0
def emv(shigh,slow,sweight):#经典emv算法,sweight即为成交量(权重)
    assert len(shigh) == len(sweight) == len(sweight)
    if(len(shigh)<1):
        return np.array([])
    mid_diff = subd((shigh + slow) / 2,1)
    box = shigh - slow
    swb = np.cast['int64'](sweight) *  BASE
    md_b2 = np.cast['int64'](mid_diff) * BASE * BASE
    ratio = np.where(box>0,swb/box,swb*10)  #box不可能小于0
    rev = np.where(ratio>0,md_b2/ratio,md_b2*10)
    rev[0] = 0
    return np.cast['int32'](rev)
Example #11
0
def emv(shigh, slow, sweight):  #经典emv算法,sweight即为成交量(权重)
    assert len(shigh) == len(sweight) == len(sweight)
    if (len(shigh) < 1):
        return np.array([])
    mid_diff = subd((shigh + slow) / 2, 1)
    box = shigh - slow
    swb = np.cast['int64'](sweight) * BASE
    md_b2 = np.cast['int64'](mid_diff) * BASE * BASE
    ratio = np.where(box > 0, swb / box, swb * 10)  #box不可能小于0
    rev = np.where(ratio > 0, md_b2 / ratio, md_b2 * 10)
    rev[0] = 0
    return np.cast['int32'](rev)
Example #12
0
def asi(sopen, sclose, shigh, slow):
    '''
        1.A=∣当天最高价-前一天收盘价∣
        B=∣当天最低价-前一天收盘价∣
        C=∣当天最高价-前一天最低价∣
        D=∣前一天收盘价-前一天开盘价∣
        2.比较A、B、C三数值:若A最大,R=A+1/2B+1/4D;若B最大,R=B+1/2A十1/4D;若C最大,R=C+1/4D
        3.  E=当天收盘价-前一天收盘价
            F=当天收盘价-当天开盘价
            G=前一天收盘价-前一天开盘价
        4.X=E+1/2F+G
        5.K=A、B之间的最大值
        6.L=3;SI=50*X/R*K/L;ASI=累计每日之SI值
    1.ASI指标大部分时机都是和股价走势同步的,投资者仅能从众多股票中寻找少数产生领先突破的个股。若ASI指标领先股价,提早突破前次ASI高点或低点,则次一日之后的股价必然能突破前次高点或低点。
    2.股价由上往下,欲穿越前一波低点的密集支撑区时,于接近低点处,尚未确定股价是否会跌破支撑之际,如果ASI领先股价,提早一步,跌破相对股价的前一波ASI低点,则次一日之后,股价将随后跌破低点支撑区。投资人可以早一步卖出股票,减少不必要的损失。
    3.股价由下往上,欲穿越前一波的高点套牢区时,于接近高点处,尚未确定股价能否顺利穿越之际,如果ASI领先股价,提早一步,通过相对股价的前一波ASI低点,则次一日之后,股价必然能够顺利突破高点套牢区。股民可以把握ASI的领先作用,提前买入股票。
    4.股价走势一波比一波高,而ASI却未相对创新高点形成“顶背离”时,应卖出;股价走势一波比一波低,而ASI却未相对创新低点形成“底背离”时,应买进。
    5.ASI指标和OBV指标同样维持“N”字型的波动,并且也以突破或跌破“N”字型高低点,为观察ASI指标的主要方法。向上爬升的ASI,一旦向下跌破其前一次显著的N型转折点,一律可视为停损卖出的讯号;向下滑落的ASI,一旦向上突破其前一次的N型转折点,一律可视为果断买进的讯号。
    #这些使用很难度量,所以其实asi只能在肉眼使用    
    '''
    a = np.abs(shigh - roll0(sclose))
    b = np.abs(slow - roll0(sclose))
    c = np.abs(shigh - roll0(slow))
    e = subd(sclose)
    f = sclose - sopen
    g = roll0(f)
    d = np.abs(g)
    l = 3

    x = e + f / 2 + g
    k = np.choose(a > b, [b, a])  #True=1,False=0,因此a>b时True=1

    m = np.select([(a > b) & (b > c), (b > c) & (b > a), (c > a) & (c > b)],
                  [a, b, c])
    r = np.select([m == a, m == b, m == c],
                  [a + b / 2 + d / 4, b + a / 2 + d / 4, c + d / 4])
    si = 50 * x / r * k / l
    return si.cumsum()
Example #13
0
def asi(sopen,sclose,shigh,slow):
    '''
        1.A=∣当天最高价-前一天收盘价∣
        B=∣当天最低价-前一天收盘价∣
        C=∣当天最高价-前一天最低价∣
        D=∣前一天收盘价-前一天开盘价∣
        2.比较A、B、C三数值:若A最大,R=A+1/2B+1/4D;若B最大,R=B+1/2A十1/4D;若C最大,R=C+1/4D
        3.  E=当天收盘价-前一天收盘价
            F=当天收盘价-当天开盘价
            G=前一天收盘价-前一天开盘价
        4.X=E+1/2F+G
        5.K=A、B之间的最大值
        6.L=3;SI=50*X/R*K/L;ASI=累计每日之SI值
    1.ASI指标大部分时机都是和股价走势同步的,投资者仅能从众多股票中寻找少数产生领先突破的个股。若ASI指标领先股价,提早突破前次ASI高点或低点,则次一日之后的股价必然能突破前次高点或低点。
    2.股价由上往下,欲穿越前一波低点的密集支撑区时,于接近低点处,尚未确定股价是否会跌破支撑之际,如果ASI领先股价,提早一步,跌破相对股价的前一波ASI低点,则次一日之后,股价将随后跌破低点支撑区。投资人可以早一步卖出股票,减少不必要的损失。
    3.股价由下往上,欲穿越前一波的高点套牢区时,于接近高点处,尚未确定股价能否顺利穿越之际,如果ASI领先股价,提早一步,通过相对股价的前一波ASI低点,则次一日之后,股价必然能够顺利突破高点套牢区。股民可以把握ASI的领先作用,提前买入股票。
    4.股价走势一波比一波高,而ASI却未相对创新高点形成“顶背离”时,应卖出;股价走势一波比一波低,而ASI却未相对创新低点形成“底背离”时,应买进。
    5.ASI指标和OBV指标同样维持“N”字型的波动,并且也以突破或跌破“N”字型高低点,为观察ASI指标的主要方法。向上爬升的ASI,一旦向下跌破其前一次显著的N型转折点,一律可视为停损卖出的讯号;向下滑落的ASI,一旦向上突破其前一次的N型转折点,一律可视为果断买进的讯号。
    #这些使用很难度量,所以其实asi只能在肉眼使用    
    '''
    a = np.abs(shigh - roll0(sclose))
    b = np.abs(slow - roll0(sclose))
    c = np.abs(shigh - roll0(slow))
    e = subd(sclose)
    f = sclose-sopen
    g = roll0(f)
    d = np.abs(g)
    l = 3
    
    x = e + f/2 + g
    k = np.choose(a>b,[b,a])   #True=1,False=0,因此a>b时True=1
    
    m = np.select([(a>b) & (b>c),(b>c) & (b>a),(c>a) & (c>b)],[a,b,c])
    r = np.select([m==a,m==b,m==c],[a+b/2+d/4,b+a/2+d/4,c+d/4])
    si = 50 * x / r * k / l    
    return si.cumsum()
Example #14
0
def prepare_common_common(s):
    o = s.transaction[OPEN]
    c = s.transaction[CLOSE]
    v = s.transaction[VOLUME]
    s.open = s.transaction[OPEN]
    s.close = s.transaction[CLOSE]
    s.vol = s.transaction[VOLUME]
    s.high = s.transaction[HIGH]
    s.low = s.transaction[LOW]
    s.ma0 = ma(c,3)
    s.ma1= ma(c,7)
    s.ma2 = ma(c,13)
    s.ma3 = ma(c,30)
    s.ma4 = ma(c,60)
    s.ma5 = ma(c,120)
    s.t5 = strend(s.ma5) > 0
    s.t4 = strend(s.ma4) > 0
    s.t3 = strend(s.ma3) > 0
    s.t2 = strend(s.ma2) > 0
    s.t1 = strend(s.ma1) > 0
    s.t0 = strend(s.ma0) > 0
    s.ksize = np.array(list(d1k.ksize(o,c)))
    s.ksign = np.array(list(d1k.ksign(o,c)))
    s.above = gand(s.ma2>s.ma3,s.ma3>s.ma4,s.ma4>s.ma5)
    #将golden和above分开
    s.golden = gand(s.g20 >= s.g60+1000,s.g60 >= s.g120+1000,s.g20>=3000,s.g20<=8000)
    s.thumb = gand(s.g20 >= s.g60,s.g60 >= s.g120,s.g120 >= s.g250,s.g20>=3000,s.g20<=8000)
    s.magic = gand(s.g5>s.g60,s.g20 >= s.g60,s.g60 >= s.g120,s.g120 >= s.g250,s.g20<8000)
    s.svap_ma_67 = svap_ma(v,c,67)
    #s.vap_ma_67 = vap_pre(v,c,67)
    #s.svap_ma_67_1 = svap_ma(v,c,67,weight=1)        
    s.svap_ma_67_2 = svap_ma(v,c,67,weight=2)        
    s.ks = subd(c) * BASE / rollx(c)
    s.diff,s.dea = cmacd(c)
    s.atr = atr(c,s.transaction[HIGH],s.transaction[LOW],20)
    s.atr2 = atr2(c,s.transaction[HIGH],s.transaction[LOW],20)
Example #15
0
def derepeatc(source):
    ''' 去除!=0数值的连续出现(只剩下第一个),正规化为1
        c是consecutive的意思
    '''
    t = subd(nequals(source,0))
    return equals(t,1)
Example #16
0
def trend(source,interval=1):
    assert interval >= 0
    return np.sign(subd(source,interval))
Example #17
0
def score2(sprice, svolume):
    si = subd(sprice) * BASE / rollx(sprice)
    fprice = np.select([si > 5, si < -5], [1, -1], default=0)
    fvolume = np.choose(subd(svolume) > 0, [1, 2])
    return fprice * fvolume
Example #18
0
def subd2(source, distance=1):  #偏移减法,distance必须大于0,返回结果中前distance个元素为0
    if source.ndim == 1:
        return d1.subd(source)
    rs = nsubd2(source, distance)
    rs[:, :distance] = 0
    return rs
Example #19
0
def score2(sprice,svolume):
    si = subd(sprice) * BASE / rollx(sprice)
    fprice = np.select([si>5,si<-5],[1,-1],default=0)
    fvolume = np.choose(subd(svolume) > 0,[1,2])
    return fprice * fvolume
Example #20
0
def trend(source, interval=1):
    assert interval >= 0
    return np.sign(subd(source, interval))
Example #21
0
def derepeatc(source):
    ''' 去除!=0数值的连续出现(只剩下第一个),正规化为1
        c是consecutive的意思
    '''
    t = subd(nequals(source, 0))
    return equals(t, 1)
Example #22
0
def subd2(source,distance=1):   #偏移减法,distance必须大于0,返回结果中前distance个元素为0
    if source.ndim == 1:
        return d1.subd(source)
    rs = nsubd2(source,distance)
    rs[:,:distance] = 0
    return rs