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)
def semv_old(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)
rev = np.zeros_like(shigh)
if (len(shigh) < length):
return rev
wma = ma(sweight, length)
dma = ma(shigh - slow, length)
premid = (shigh[length - 1] + slow[length - 1]) / 2
for i in xrange(length, len(shigh)): #除0都当作除0.1，即*10
csh, csl, csw = shigh[i], slow[i], sweight[i]
pwm, pdm = wma[i - 1], dma[i - 1]
mid = (csh + csl) / 2
mid_rate = (mid - premid) * BASE * BASE / mid
sweight_rate = pwm > 0 and csw * BASE / pwm or csw * BASE * 10 #除数为0当作0.1
wave_rate = pdm > 0 and (csh - csl) * BASE / pdm or (csh -
csl) * BASE * 10
rev[i] = sweight_rate > 0 and mid_rate * wave_rate / sweight_rate or mid_rate * wave_rate * 10 #除数为0当作0.1
#print premid,mid,mid_rate,sweight_rate,wave_rate
premid = mid
return rev
def semv_old(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)
rev = np.zeros_like(shigh)
if(len(shigh)<length):
return rev
wma = ma(sweight,length)
dma = ma(shigh - slow,length)
premid = (shigh[length-1] + slow[length-1]) /2
for i in xrange(length,len(shigh)): #除0都当作除0.1，即*10
csh,csl,csw = shigh[i],slow[i],sweight[i]
pwm,pdm = wma[i-1],dma[i-1]
mid = (csh + csl) /2
mid_rate = (mid-premid) * BASE * BASE / mid
sweight_rate = pwm > 0 and csw * BASE/pwm or csw * BASE * 10 #除数为0当作0.1
wave_rate = pdm > 0 and (csh-csl)*BASE/pdm or (csh-csl)*BASE * 10
rev[i] = sweight_rate > 0 and mid_rate*wave_rate/sweight_rate or mid_rate*wave_rate * 10 #除数为0当作0.1
#print premid,mid,mid_rate,sweight_rate,wave_rate
premid = mid
return rev
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)
def smacd(source,ifast=12,islow=26,idiff=9):
''' 简单MACD，用MA替代CEXPMA
'''
fast = ma(source,ifast)
slow = ma(source,islow)
diff = fast - slow
dea = ma(diff,idiff)
return diff,dea
def smacd(source, ifast=12, islow=26, idiff=9):
''' 简单MACD，用MA替代CEXPMA
'''
fast = ma(source, ifast)
slow = ma(source, islow)
diff = fast - slow
dea = ma(diff, idiff)
return diff, dea
def temv(shigh, slow, sweight, length=14, BASE=100): #国内常用的emv方式
''' BASE设定为100是考虑到mid的精度问题，同时又不至于溢出
VOLUME:=MA(VOL,N)/VOL;
MID:=100*(HIGH+LOW-REF(HIGH+LOW,1))/(HIGH+LOW);
EMV:MA(MID*VOLUME*(HIGH-LOW)/MA(HIGH-LOW,N),N);
MAEMV:MA(EMV,M);
'''
mvol = ma(sweight, length) * BASE / sweight
ahl = shigh + slow
jhl = shigh - slow
mid = (ahl - rollx(ahl)) * BASE * BASE / ahl
rev = ma(mid * mvol * jhl / ma(jhl, length), length)
return rev
def temv(shigh,slow,sweight,length=14,BASE=100):#国内常用的emv方式
''' BASE设定为100是考虑到mid的精度问题，同时又不至于溢出
VOLUME:=MA(VOL,N)/VOL;
MID:=100*(HIGH+LOW-REF(HIGH+LOW,1))/(HIGH+LOW);
EMV:MA(MID*VOLUME*(HIGH-LOW)/MA(HIGH-LOW,N),N);
MAEMV:MA(EMV,M);
'''
mvol = ma(sweight,length) * BASE / sweight
ahl = shigh + slow
jhl = shigh - slow
mid = (ahl-rollx(ahl))*BASE*BASE/ahl
rev = ma(mid*mvol*jhl/ma(jhl,length),length)
return rev
def skdj(shigh,slow,sclose,n=9,m=3):
lowv = tmin(slow,n)
highv = tmax(shigh,n)
rsv = cexpma((sclose-lowv)*100/(highv-lowv),m)
k = cexpma(rsv,m)
d = ma(k,m)
return k,d
def skdj(shigh, slow, sclose, n=9, m=3):
lowv = tmin(slow, n)
highv = tmax(shigh, n)
rsv = cexpma((sclose - lowv) * 100 / (highv - lowv), m)
k = cexpma(rsv, m)
d = ma(k, m)
return k, d
def cci(shigh,slow,sclose,length):
'''
cci路径指标
'''
typ = (shigh+slow+sclose)/3
rev = (typ-ma(typ,length))/(0.015*avedev(typ,length))
rev[:length-1] = 0
return np.cast['int32'](rev*BASE)
def cci(shigh, slow, sclose, length):
'''
cci路径指标
'''
typ = (shigh + slow + sclose) / 3
rev = (typ - ma(typ, length)) / (0.015 * avedev(typ, length))
rev[:length - 1] = 0
return np.cast['int32'](rev * BASE)
def adx2(sclose,shigh,slow,n=14,m=6):
'''
调整的算法, abs在ma之后取值
直接根据sclose,shigh,slow计算adx的快捷函数
n: 计算di时的平滑天数
m: 计算adx时的平滑天数
'''
pdm,ndm = dm(shigh,slow)
xtr = msum(tr(sclose,shigh,slow),n)
pdi = msum(pdm,n)*10000/xtr
ndi = msum(ndm,n)*10000/xtr
adx = np.abs(ma((pdi-ndi)*10000/(pdi+ndi),m))
#adxr = (adx + rollx(adx,m)) /2
return pdi,ndi,adx#,adxr
def adx2(sclose, shigh, slow, n=14, m=6):
'''
调整的算法, abs在ma之后取值
直接根据sclose,shigh,slow计算adx的快捷函数
n: 计算di时的平滑天数
m: 计算adx时的平滑天数
'''
pdm, ndm = dm(shigh, slow)
xtr = msum(tr(sclose, shigh, slow), n)
pdi = msum(pdm, n) * 10000 / xtr
ndi = msum(ndm, n) * 10000 / xtr
adx = np.abs(ma((pdi - ndi) * 10000 / (pdi + ndi), m))
#adxr = (adx + rollx(adx,m)) /2
return pdi, ndi, adx #,adxr
def adx0(sclose,shigh,slow,n=14,m=6):
'''
原始的adx计算方法
直接根据sclose,shigh,slow计算adx的快捷函数
n: 计算di时的平滑天数
m: 计算adx时的平滑天数
'''
pdm,ndm = dm(shigh,slow)
xtr = msum(tr(sclose,shigh,slow),n)
pdi = msum(pdm,n)*10000/xtr
ndi = msum(ndm,n)*10000/xtr
adx = ma(np.abs((pdi-ndi)*10000/(pdi+ndi)),m)
#adxr = (adx + rollx(adx,m)) /2
return pdi,ndi,adx#,adxr
def adx0(sclose, shigh, slow, n=14, m=6):
'''
原始的adx计算方法
直接根据sclose,shigh,slow计算adx的快捷函数
n: 计算di时的平滑天数
m: 计算adx时的平滑天数
'''
pdm, ndm = dm(shigh, slow)
xtr = msum(tr(sclose, shigh, slow), n)
pdi = msum(pdm, n) * 10000 / xtr
ndi = msum(ndm, n) * 10000 / xtr
adx = ma(np.abs((pdi - ndi) * 10000 / (pdi + ndi)), m)
#adxr = (adx + rollx(adx,m)) /2
return pdi, ndi, adx #,adxr
def ma2(v2,length): #利用一维数组的ma算法
row_number = v2.shape[0]
rev = np.zeros_like(v2)
for i in xrange(row_number):
rev[i] = ma(v2[i],length)
return rev
def svap2_ma(svolume,sprice,malength,weight=5):
''' 依赖svolume为整数序列，否则导致ma之后0值有非零的base，直接导致后续所有计算出错
weight为权数，unit单位ma再除以weight. unit的粒度越细，一致性越好
'''
return svap2(svolume,sprice,rollx(ma(svolume,malength)/weight))
def adtr2(sopen, sclose, shigh, slow, length=20):
return ma(dtr(sopen, sclose, shigh, slow), length)
def atr2(sclose, shigh, slow, length=20):
return ma(tr(sclose, shigh, slow), length)
def cho(shigh, slow, sclose, svol, n1=10, n2=20, m=6):
mid = np.cumsum(svol * (2 * sclose - shigh - slow) / (shigh + slow), 0)
cho = ma(mid, n1) - ma(mid, n2)
macho = ma(cho, m)
return cho, macho
def cho(shigh,slow,sclose,svol,n1=10,n2=20,m=6):
mid = np.cumsum(svol*(2*sclose-shigh-slow)/(shigh+slow),0);
cho = ma(mid,n1) - ma(mid,n2)
macho = ma(cho,m)
return cho,macho
def svap2_ma(svolume, sprice, malength, weight=5):
''' 依赖svolume为整数序列，否则导致ma之后0值有非零的base，直接导致后续所有计算出错
weight为权数，unit单位ma再除以weight. unit的粒度越细，一致性越好
'''
return svap2(svolume, sprice, rollx(ma(svolume, malength) / weight))
def atr2(sclose,shigh,slow,length=20):
return ma(tr(sclose,shigh,slow),length)
def adtr2(sopen,sclose,shigh,slow,length=20):
return ma(dtr(sopen,sclose,shigh,slow),length)
def ma2a(v2,length): #v2是array的list
row_number = len(v2)
rev = [0] * row_number
for i in xrange(row_number):
rev[i] = ma(v2[i],length)
return rev
def ma2a(v2, length): #v2是array的list
row_number = len(v2)
rev = [0] * row_number
for i in xrange(row_number):
rev[i] = ma(v2[i], length)
return rev
def ma2(v2, length): #利用一维数组的ma算法
row_number = v2.shape[0]
rev = np.zeros_like(v2)
for i in xrange(row_number):
rev[i] = ma(v2[i], length)
return rev
