예제 #1
0
def ldevi(slow,
          ref_quick,
          ref_slow,
          sbase=None,
          covered=20,
          distance=1,
          delta=0):
    '''
        底背离
        ref_quick,ref_slow用于确认顶底
        sbase是比较线,即顶底确认后的比较
        distance表示与前面第几个底背离
        delta:平滑系数,低点如果高delta也算新低
        这个算法根据macd下叉来确认底,可能更好?
    '''
    if sbase == None:
        sbase = ref_quick
    sc = gand(cross(ref_slow, ref_quick) > 0)
    xlow = tmin(slow, covered)
    dlow = tmin(sbase, covered)
    #print sc,xlow.tolist(),dlow.tolist()
    dxlow = rsub2(xlow, sc, distance)
    ddlow = rsub2(dlow, sc, distance)
    #print dxlow,ddlow
    signal = gand(dxlow - delta < 0, ddlow > 0)
    return signal
예제 #2
0
def uplines(*args):
    ''' args[0]...args[-1]各个序列多头排列,其中args[0]为最快速线
    '''
    trends = [trend(s) > 0 for s in args]
    sdiff = np.diff(args, axis=0)
    sdiff0 = [s < 0 for s in sdiff]
    strend = gand(*trends)
    return gand(strend, *sdiff0)
예제 #3
0
def uplines(*args):
    ''' args[0]...args[-1]各个序列多头排列,其中args[0]为最快速线
    '''
    trends = [ trend(s)>0 for s in args ]
    sdiff = np.diff(args,axis=0)
    sdiff0 = [ s<0 for s in sdiff]
    strend = gand(*trends)
    return gand(strend,*sdiff0)
예제 #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
예제 #5
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
예제 #6
0
def devi(shigh, sdiff, regr=96):
    '''
        背离,是指shigh新高头部形成时,sdiff没有创相应周期的新高
        shigh:高点序列
        sdiff:macd的diff序列
        regr:回撤比例
    '''
    xhigh = tmax(shigh, 7)
    xhighl = xhigh * regr / 100
    xhighA = gand(shigh < xhighl, rollx(shigh, 6) < xhigh)
    xhigh60 = tmax(shigh, 60)
    xdiff7 = tmax(sdiff, 7)
    xdiff60 = tmax(sdiff, 60)
    xdev = gand(xhighA, xhigh == xhigh60, xdiff7 < xdiff60)
    return xdev
예제 #7
0
파일: d1ex.py 프로젝트: pophoo/foxengine
def devi(shigh,sdiff,regr=96):
    '''
        背离,是指shigh新高头部形成时,sdiff没有创相应周期的新高
        shigh:高点序列
        sdiff:macd的diff序列
        regr:回撤比例
    '''
    xhigh = tmax(shigh,7)
    xhighl = xhigh * regr/100
    xhighA = gand(shigh < xhighl,rollx(shigh,6)<xhigh)
    xhigh60 =tmax(shigh,60)
    xdiff7 = tmax(sdiff,7)
    xdiff60 = tmax(sdiff,60)
    xdev = gand(xhighA,xhigh == xhigh60,xdiff7<xdiff60)
    return xdev
예제 #8
0
def decover1(source, interval=1):
    ''' 去除间隔期内!=0数值的重复出现,并将信号标准化为1
        新的信号会增强interval. 
        去除效率大于derepeatc
    '''
    nsource = nequals(source, 0)
    ms = msum2(nsource, interval + 1)  #间隔0为本位和,间隔1位本左邻和
    return gand(equals(ms, 1), nsource)
예제 #9
0
파일: d1ex.py 프로젝트: pophoo/foxengine
def decover1(source,interval=1):
    ''' 去除间隔期内!=0数值的重复出现,并将信号标准化为1
        新的信号会增强interval. 
        去除效率大于derepeatc
    '''
    nsource = nequals(source,0)
    ms = msum2(nsource,interval+1)  #间隔0为本位和,间隔1位本左邻和
    return gand(equals(ms,1),nsource)
예제 #10
0
def gtrend1(shigh, slow):
    ''' 
        江恩1周期趋势线
        #返回trend线,top,bottom线
        返回trend线,使用时可用strend2来判断当前趋势,当up时当前点为高点,down时为低点
        如果要找到高点之前的地点,可以用strend2作为选择,找到这些点,然后extend2next
        如:     t1=strend2(gtrend)
                thigh = np.select([t1>0],[gtrend])
                thigh = extend2next(thigh)
            如此就取到了高点序列,同理可得到低点序列

    一日摆动由江恩定义. 1日转向图. 
        上升日(Up down:UD): 高点高,低点高
        下降日(Down day:DD): 高点低,低点低
        外延日(Outside day,OD):高点高,低点低
        内移日(Inside day:ID):高点低,低点高

        上升日则趋势线移动到高点,下降日则趋势线移动到低点
        上升趋势中的外延日,如果先高后低,则移动到低点,否则移动到高点,#这里简单起见,都算延续趋势
        下降趋势中的外延日,如果先低后高,则移动到高点,否则移动到高点,#这里简单起见,都算延续趋势
        忽略内移日

        top:上行中的高点,或转为下行前的上一个高点
        bottom: 下行中的低点,或转为上行前的上一个低点
            
    '''
    dup = gand(shigh > rollx(shigh), slow > rollx(slow))
    ddown = gand(shigh < rollx(shigh), slow < rollx(slow))
    dexpand = gand(shigh > rollx(shigh), slow < rollx(slow))
    #dinside = gand(shigh<rollx(shigh),slow>rollx(slow))    #忽略

    #先不计扩张日,得到原始趋势
    st = np.select([dup, ddown], [shigh, slow], 0)
    st = extend2next(st)
    t1 = strend2(st)

    st2 = np.select(
        [dup, gand(dexpand, t1 > 0), ddown,
         gand(dexpand, t1 < 0)], [shigh, shigh, slow, slow])
    #st_top = np.select([dup,gand(dexpand,t1>0)],[shigh,shigh])
    #st_bottom = np.select([ddown,gand(dexpand,t1<0)],[slow,slow])
    st2 = extend2next(st2)
    #st_top = extend2next(st_top)
    #st_bottom = extend2next(st_bottom)
    return st2  #,st_top,st_bottom
예제 #11
0
파일: d1ex.py 프로젝트: pophoo/foxengine
def lpeak(slow,ref_quick,ref_slow,covered=10):
    '''
        寻找最近低点
        ref_quick,ref_slow(skdj/k,skdj/d)用于确认顶底
        用一分钟skdj的时候,比较快捷,所以covered默认为10
    '''
    sc = gand(cross(ref_slow,ref_quick)>0)
    xlow = tmin(slow,covered)
    return np.select([sc],[xlow],0)
예제 #12
0
파일: d1ex.py 프로젝트: pophoo/foxengine
def hpeak(shigh,ref_quick,ref_slow,covered=10):
    '''
        寻找最近高点
        ref_quick,ref_slow(skdj/k,skdj/d)用于确认顶底
        用一分钟skdj的时候,比较快捷,所以covered默认为10
    '''
    sc = gand(cross(ref_slow,ref_quick)<0)
    xhigh = tmax(shigh,covered)
    return np.select([sc],[xhigh],0)
예제 #13
0
파일: d1ex.py 프로젝트: pophoo/foxengine
def hdevi(shigh,ref_quick,ref_slow,sbase=None,covered=20,distance=1,delta=0):
    '''
        顶背离
        ref_quick,ref_slow(sdiff,ref_slow)用于确认顶底
        sbase是比较线,即顶底确认后的比较
        distance表示与前面第几个顶背离
        delta:平滑系数,高点如果低delta也算新高
        这个算法根据macd下叉来确认顶,可能更好?
    '''
    if sbase == None:
        sbase = ref_quick
    sc = gand(cross(ref_slow,ref_quick)<0)
    xhigh = tmax(shigh,covered)
    dhigh = tmax(sbase,covered)
    dxhigh = rsub2(xhigh,sc,distance)
    ddhigh = rsub2(dhigh,sc,distance)
    signal = gand(dxhigh + delta>0,ddhigh<0)
    return signal
예제 #14
0
def lpeak(slow, ref_quick, ref_slow, covered=10):
    '''
        寻找最近低点
        ref_quick,ref_slow(skdj/k,skdj/d)用于确认顶底
        用一分钟skdj的时候,比较快捷,所以covered默认为10
    '''
    sc = gand(cross(ref_slow, ref_quick) > 0)
    xlow = tmin(slow, covered)
    return np.select([sc], [xlow], 0)
예제 #15
0
def hpeak(shigh, ref_quick, ref_slow, covered=10):
    '''
        寻找最近高点
        ref_quick,ref_slow(skdj/k,skdj/d)用于确认顶底
        用一分钟skdj的时候,比较快捷,所以covered默认为10
    '''
    sc = gand(cross(ref_slow, ref_quick) < 0)
    xhigh = tmax(shigh, covered)
    return np.select([sc], [xhigh], 0)
예제 #16
0
def gtrend1(shigh,slow):
    ''' 
        江恩1周期趋势线
        #返回trend线,top,bottom线
        返回trend线,使用时可用strend2来判断当前趋势,当up时当前点为高点,down时为低点
        如果要找到高点之前的地点,可以用strend2作为选择,找到这些点,然后extend2next
        如:     t1=strend2(gtrend)
                thigh = np.select([t1>0],[gtrend])
                thigh = extend2next(thigh)
            如此就取到了高点序列,同理可得到低点序列

    一日摆动由江恩定义. 1日转向图. 
        上升日(Up down:UD): 高点高,低点高
        下降日(Down day:DD): 高点低,低点低
        外延日(Outside day,OD):高点高,低点低
        内移日(Inside day:ID):高点低,低点高

        上升日则趋势线移动到高点,下降日则趋势线移动到低点
        上升趋势中的外延日,如果先高后低,则移动到低点,否则移动到高点,#这里简单起见,都算延续趋势
        下降趋势中的外延日,如果先低后高,则移动到高点,否则移动到高点,#这里简单起见,都算延续趋势
        忽略内移日

        top:上行中的高点,或转为下行前的上一个高点
        bottom: 下行中的低点,或转为上行前的上一个低点
            
    '''
    dup = gand(shigh>rollx(shigh),slow>rollx(slow))
    ddown = gand(shigh<rollx(shigh),slow<rollx(slow))
    dexpand = gand(shigh>rollx(shigh),slow<rollx(slow))
    #dinside = gand(shigh<rollx(shigh),slow>rollx(slow))    #忽略

    #先不计扩张日,得到原始趋势
    st = np.select([dup,ddown],[shigh,slow],0)
    st = extend2next(st)
    t1 = strend2(st)

    st2 = np.select([dup,gand(dexpand,t1>0),ddown,gand(dexpand,t1<0)],[shigh,shigh,slow,slow])
    #st_top = np.select([dup,gand(dexpand,t1>0)],[shigh,shigh])
    #st_bottom = np.select([ddown,gand(dexpand,t1<0)],[slow,slow])    
    st2 = extend2next(st2)
    #st_top = extend2next(st_top)
    #st_bottom = extend2next(st_bottom)
    return st2  #,st_top,st_bottom
예제 #17
0
파일: d1ex.py 프로젝트: pophoo/foxengine
def ldevi(slow,ref_quick,ref_slow,sbase=None,covered=20,distance=1,delta=0):
    '''
        底背离
        ref_quick,ref_slow用于确认顶底
        sbase是比较线,即顶底确认后的比较
        distance表示与前面第几个底背离
        delta:平滑系数,低点如果高delta也算新低
        这个算法根据macd下叉来确认底,可能更好?
    '''
    if sbase == None:
        sbase = ref_quick
    sc = gand(cross(ref_slow,ref_quick)>0)
    xlow = tmin(slow,covered)
    dlow = tmin(sbase,covered)
    #print sc,xlow.tolist(),dlow.tolist()
    dxlow = rsub2(xlow,sc,distance)
    ddlow = rsub2(dlow,sc,distance)
    #print dxlow,ddlow
    signal = gand(dxlow-delta<0,ddlow>0)
    return signal
예제 #18
0
파일: d1ex.py 프로젝트: pophoo/foxengine
def gsyntony(*args):
    ''' 简单共振的多参数版本
        为保持接口的一致性,如果args[-1]为整数,则为covered参数,否则covered=1. 其余的args都是序列 
        args中的序列信号不论先后,在covered天中同时出现,则以匹配日(后个信号出现的那一天)为信号发出日
        covered =1 为同一天发出信号,<1视同为1
        要求args的元素在本序列内部都是同号的(但args之间可以不同号)
        注意:args各序列非零为有信号
    '''
    assert len(args) >= 2
    sources,covered = _iargsparse(1,*args)
    ss = [msum2(s,covered) for s in sources]
    return gand(*ss)
예제 #19
0
def gsyntony(*args):
    ''' 简单共振的多参数版本
        为保持接口的一致性,如果args[-1]为整数,则为covered参数,否则covered=1. 其余的args都是序列 
        args中的序列信号不论先后,在covered天中同时出现,则以匹配日(后个信号出现的那一天)为信号发出日
        covered =1 为同一天发出信号,<1视同为1
        要求args的元素在本序列内部都是同号的(但args之间可以不同号)
        注意:args各序列非零为有信号
    '''
    assert len(args) >= 2
    sources, covered = _iargsparse(1, *args)
    ss = [msum2(s, covered) for s in sources]
    return gand(*ss)
예제 #20
0
def hdevi(shigh,
          ref_quick,
          ref_slow,
          sbase=None,
          covered=20,
          distance=1,
          delta=0):
    '''
        顶背离
        ref_quick,ref_slow(sdiff,ref_slow)用于确认顶底
        sbase是比较线,即顶底确认后的比较
        distance表示与前面第几个顶背离
        delta:平滑系数,高点如果低delta也算新高
        这个算法根据macd下叉来确认顶,可能更好?
    '''
    if sbase == None:
        sbase = ref_quick
    sc = gand(cross(ref_slow, ref_quick) < 0)
    xhigh = tmax(shigh, covered)
    dhigh = tmax(sbase, covered)
    dxhigh = rsub2(xhigh, sc, distance)
    ddhigh = rsub2(dhigh, sc, distance)
    signal = gand(dxhigh + delta > 0, ddhigh < 0)
    return signal
예제 #21
0
파일: d1ex.py 프로젝트: pophoo/foxengine
    pre_v = source[0]
    cur = 0
    for i in xrange(1,len(source)):
        cur_v = source[i]
        if cur_v > pre_v:
            cur = cur + 1 if cur > 0 else 1
        elif cur_v < pre_v:
            cur = cur - 1 if cur < 0 else -1
        else: #curv == pre_v
            cur = cur + 1 if cur >= 0 else cur-1 #最初为0时,也算上升
        rev[i] = cur
        pre_v = cur_v
    return rev    

#趋势的翻转次数
rturn = lambda sx:sum(gor(gand(rollx(sx)>0,sx<0),gand(rollx(sx)<0,sx>0)))


def cross(target,follow):
    ''' 交叉计算:   target: 参照系,follow: 追击者
        状态:  1   Follow上叉Target
                0   无交叉状态 
                -1  Follow下叉

        粘合一次后按趋势发散仍然算叉,即追击--追平--超越也算,但追击--追平--平--....--超越不算
        这里不保证Target在上叉(下叉)时的趋势是向上(向下)的
    '''
    assert len(target) == len(follow)
    if(len(target) == 0):
        return target.copy()
    s = np.sign(follow - target)
예제 #22
0
    for i in xrange(1, len(source)):
        cur_v = source[i]
        if cur_v > pre_v:
            cur = cur + 1 if cur > 0 else 1
        elif cur_v < pre_v:
            cur = cur - 1 if cur < 0 else -1
        else:  #curv == pre_v
            cur = cur + 1 if cur >= 0 else cur - 1  #最初为0时,也算上升
        rev[i] = cur
        pre_v = cur_v
    return rev


#趋势的翻转次数
rturn = lambda sx: sum(
    gor(gand(rollx(sx) > 0, sx < 0), gand(rollx(sx) < 0, sx > 0)))


def cross(target, follow):
    ''' 交叉计算:   target: 参照系,follow: 追击者
        状态:  1   Follow上叉Target
                0   无交叉状态 
                -1  Follow下叉

        粘合一次后按趋势发散仍然算叉,即追击--追平--超越也算,但追击--追平--平--....--超越不算
        这里不保证Target在上叉(下叉)时的趋势是向上(向下)的
    '''
    assert len(target) == len(follow)
    if (len(target) == 0):
        return target.copy()
    s = np.sign(follow - target)