#!/usr/bin/python
# -*- coding: utf-8 -*-

import numpy as np
import pandas as pd


def EMA(number, n):
	return pd.Series(number).ewm(alpha=2 / (n + 1), adjust=True).mean()


def MA(number, n):
	return pd.Series.rolling(number, n).mean()


def SMA(number, n, m=1):
	_df = number.fillna(0)
	return pd.Series(_df).ewm(com=n - m, adjust=True).mean()


def RM_SMA(DF, N, M):
	DF = DF.fillna(0)
	z = len(DF)
	var = np.zeros(z)
	var[0] = DF[0]
	for i in range(1, z):
		var[i] = (DF[i] * M + var[i - 1] * (N - M)) / N
	for i in range(z):
		DF[i] = var[i]
	return DF


def ATR(close, high, low, n):
	"""
	真实波幅
	:param close:
	:param high:
	:param low:
	:param n:
	:return:
	"""
	c, h, l_ = close, high, low
	mtr = MAX(MAX((h - l_), ABS(REF(c, 1) - h)), ABS(REF(c, 1) - l_))
	atr = MA(mtr, n)
	return pd.DataFrame({'MTR': mtr, 'ATR': atr})


def HHV(number, n):
	return pd.Series.rolling(number, n).max()


def LLV(number, n):
	return pd.Series.rolling(number, n).min()


def SUM(number, n):
	return pd.Series.rolling(number, n).sum()


def ABS(number):
	return np.abs(number)


def MAX(A, B):
	return np.maximum(A, B)


def MIN(A, B):
	var = IF(A < B, A, B)
	return var


def IF(COND, V1, V2):
	var = np.flip(np.where(COND, V1, V2))
	return pd.Series(var)[::-1]


def REF(DF, N):
	var = DF.diff(N)
	var = DF - var
	return var


def STD(number, n):
	return pd.Series.rolling(number, n).std()


def MACD(close, f, s, m):
	"""

	:param close:
	:param f:
	:param s:
	:param m:
	:return:
	"""
	EMAFAST = EMA(close, f)
	EMASLOW = EMA(close, s)
	DIFF = EMAFAST - EMASLOW
	DEA = EMA(DIFF, m)
	MACD = (DIFF - DEA) * 2
	return pd.DataFrame({
		'DIFF': round(DIFF, 2),
		'DEA': round(DEA, 2), 'MACD': round(MACD, 2)})


def KDJ(close, high, low, n, m1, m2):
	"""

	:param close:
	:param high:
	:param low:
	:param n:
	:param m1:
	:param m2:
	:return:
	"""
	c, h, l = close, high, low
	RSV = (c - LLV(l, n)) / (HHV(h, n) - LLV(l, n)) * 100
	K = SMA(RSV, m1, 1)
	D = SMA(K, m2, 1)
	J = 3 * K - 2 * D
	return pd.DataFrame({'KDJ_K': round(K, 2), 'KDJ_D': round(D, 2), 'KDJ_J': round(J, 2)})


def OSC(close, n, m):
	"""
	变动速率线
	:param close:
	:param n:
	:param m:
	:return:
	"""
	c = close
	OS = (c - MA(c, n)) * 100
	MAOSC = EMA(OS, m)
	return pd.DataFrame({'OSC': OS, 'MAOSC': MAOSC})


def BBI(close, N1, N2, N3, N4):
	"""
	多空指标
	:param close:
	:param N1:
	:param N2:
	:param N3:
	:param N4:
	:return:
	"""
	bbi = (MA(close, N1) + MA(close, N2) + MA(close, N3) + MA(close, N4)) / 4
	return pd.DataFrame({'BBI': round(bbi, 2)})


def BBIBOLL(close, n, m, n1=3, n2=6, n3=12, n4=24):
	"""
	多空布林线
	:param close:
	:param n1:
	:param n2:
	:param n3:
	:param n4:
	:param n:
	:param m:
	:return:
	"""
	bbi_boll = BBI(close, n1, n2, n3, n4)['BBI']
	UPER = bbi_boll + m * STD(bbi_boll, n)
	DOWN = bbi_boll - m * STD(bbi_boll, n)
	return pd.DataFrame({'BBIBOLL': round(bbi_boll, 2), 'UPER': round(UPER, 2), 'DOWN': round(DOWN, 2)})


def PBX(close, n1, n2, n3, n4, n5, n6):
	"""
	瀑布线
	:param close:
	:param n1:
	:param n2:
	:param n3:
	:param n4:
	:param n5:
	:param n6:
	:return:
	"""
	c = close
	PBX1 = (EMA(c, n1) + MA(c, 2 * n1) + MA(c, 4 * n1)) / 3
	PBX2 = (EMA(c, n2) + MA(c, 2 * n2) + MA(c, 4 * n2)) / 3
	PBX3 = (EMA(c, n3) + MA(c, 2 * n3) + MA(c, 4 * n3)) / 3
	PBX4 = (EMA(c, n4) + MA(c, 2 * n4) + MA(c, 4 * n4)) / 3
	PBX5 = (EMA(c, n5) + MA(c, 2 * n5) + MA(c, 4 * n5)) / 3
	PBX6 = (EMA(c, n6) + MA(c, 2 * n6) + MA(c, 4 * n6)) / 3
	return pd.DataFrame(
		{'PBX1': round(PBX1, 2), 'PBX2': round(PBX2, 2), 'PBX3': round(PBX3, 2),
		 'PBX4': round(PBX4, 2), 'PBX5': round(PBX5, 2), 'PBX6': round(PBX6, 2)}
	)


def BOLL(close, N):  # 布林线
	boll = MA(close, N)
	UB = boll + 2 * STD(close, N)
	LB = boll - 2 * STD(close, N)
	return pd.DataFrame({'BOLL': round(boll, 2), 'UB': round(UB, 2), 'LB': round(LB, 2)})


def ROC(close, n, m):
	"""
	变动率指标
	:param close:
	:param n:
	:param m:
	:return:
	"""
	c = close
	roc = 100 * (c - REF(c, n)) / REF(c, n)
	maroc = MA(roc, m)
	return pd.DataFrame({'ROC': round(roc, 2), 'MAROC': round(maroc, 2)})


def MTM(close, n, m):
	"""
	动量线
	:param close:
	:param n:
	:param m:
	:return:
	"""
	c = close
	mtm = c - REF(c, n)
	mtm_ma = MA(mtm, m)
	return pd.DataFrame({'MTM': round(mtm, 2), 'MTMMA': round(mtm_ma, 2)})


def MFI(close, high, low, vol, n):
	"""
	资金指标
	:param close:
	:param high:
	:param low:
	:param vol:
	:param n:
	:return:
	"""
	c, h, l, v = close, high, low, vol
	TYP = (c + h + l) / 3
	V1 = SUM(IF(TYP > REF(TYP, 1), TYP * v, 0), n) / \
		 SUM(IF(TYP < REF(TYP, 1), TYP * v, 0), n)
	mfi = 100 - (100 / (1 + V1))
	return pd.DataFrame({'MFI': round(mfi, 2)})


def SKDJ(close, high, low, N, M):
	c = close
	LOWV = LLV(low, N)
	HIGHV = HHV(high, N)
	RSV = EMA((c - LOWV) / (HIGHV - LOWV) * 100, M)
	K = EMA(RSV, M)
	D = MA(K, M)
	return pd.DataFrame({'SKDJ_K': round(K, 2), 'SKDJ_D': round(D, 2)})


def WR(close, high, low, N, N1):
	"""
	威廉指标
	:param close:
	:param high:
	:param low:
	:param N:
	:param N1:
	:return:
	"""
	c, h, l = close, high, low
	WR1 = round(100 * (HHV(h, N) - c) / (HHV(h, N) - LLV(l, N)), 2)
	WR2 = round(100 * (HHV(h, N1) - c) / (HHV(h, N1) - LLV(l, N1)), 2)
	return pd.DataFrame({'WR1': round(WR1, 2), 'WR2': round(WR2, 2)})


def BIAS(DF, N1, N2, N3):  # 乖离率
	CLOSE = DF
	BIAS1 = (CLOSE - MA(CLOSE, N1)) / MA(CLOSE, N1) * 100
	BIAS2 = (CLOSE - MA(CLOSE, N2)) / MA(CLOSE, N2) * 100
	BIAS3 = (CLOSE - MA(CLOSE, N3)) / MA(CLOSE, N3) * 100
	DICT = {'BIAS1': BIAS1, 'BIAS2': BIAS2, 'BIAS3': BIAS3}
	VAR = pd.DataFrame(DICT)
	return VAR


def RSI(c, N1, N2, N3):  # 相对强弱指标RSI1:SMA(MAX(CLOSE-LC,0),N1,1)/SMA(ABS(CLOSE-LC),N1,1)*100;
	DIF = c - REF(c, 1)
	RSI1 = round((SMA(MAX(DIF, 0), N1) / round(SMA(ABS(DIF), N1) * 100, 3)) * 10000, 2)
	RSI2 = round((SMA(MAX(DIF, 0), N2) / round(SMA(ABS(DIF), N2) * 100, 3)) * 10000, 2)
	RSI3 = round((SMA(MAX(DIF, 0), N3) / round(SMA(ABS(DIF), N3) * 100, 3)) * 10000, 2)
	return pd.DataFrame({'RSI1': RSI1, 'RSI2': RSI2, 'RSI3': RSI3})


def ADTM(DF, N, M):  # 动态买卖气指标
	HIGH = DF['high']
	LOW = DF['low']
	OPEN = DF['open']
	DTM = IF(OPEN <= REF(OPEN, 1), 0, MAX(
		(HIGH - OPEN), (OPEN - REF(OPEN, 1))))
	DBM = IF(OPEN >= REF(OPEN, 1), 0, MAX((OPEN - LOW), (OPEN - REF(OPEN, 1))))
	STM = SUM(DTM, N)
	SBM = SUM(DBM, N)
	ADTM1 = IF(STM > SBM, (STM - SBM) / STM,
			   IF(STM == SBM, 0, (STM - SBM) / SBM))
	MAADTM = MA(ADTM1, M)
	DICT = {'ADTM': ADTM1, 'MAADTM': MAADTM}
	VAR = pd.DataFrame(DICT)
	return VAR


def DDI(DF, N, N1, M, M1):  # 方向标准离差指数
	H = DF['high']
	L = DF['low']
	DMZ = IF((H + L) <= (REF(H, 1) + REF(L, 1)), 0,
			 MAX(ABS(H - REF(H, 1)), ABS(L - REF(L, 1))))
	DMF = IF((H + L) >= (REF(H, 1) + REF(L, 1)), 0,
			 MAX(ABS(H - REF(H, 1)), ABS(L - REF(L, 1))))
	DIZ = SUM(DMZ, N) / (SUM(DMZ, N) + SUM(DMF, N))
	DIF = SUM(DMF, N) / (SUM(DMF, N) + SUM(DMZ, N))
	ddi = DIZ - DIF
	ADDI = SMA(ddi, N1, M)
	AD = MA(ADDI, M1)
	DICT = {'DDI': ddi, 'ADDI': ADDI, 'AD': AD}
	VAR = pd.DataFrame(DICT)
	return VAR


ZIG_STATE_START = 0
ZIG_STATE_RISE = 1
ZIG_STATE_FALL = 2


def ZIG(d, k, n):
	"""
	之字转向指标，当前价格变化超过 x% 时候变化
	:param d: 交易日期
	:param k: 价格
	:param n: 系数
	:return:
	"""
	x = round(n / 100, 2)
	peer_i = 0
	candidate_i = None
	scan_i = 0
	peers = [0]
	z = np.zeros(len(k))
	state = ZIG_STATE_START
	while True:
		scan_i += 1
		if scan_i == len(k) - 1:
			# 扫描到尾部
			if candidate_i is None:
				peer_i = scan_i
				peers.append(peer_i)
			else:
				if state == ZIG_STATE_RISE:
					if k[scan_i] >= k[candidate_i]:
						print(d[scan_i], "1 --->>>", d[candidate_i])
						peer_i = scan_i
						peers.append(peer_i)
					else:
						peer_i = candidate_i
						peers.append(peer_i)
						peer_i = scan_i
						peers.append(peer_i)
				elif state == ZIG_STATE_FALL:
					if k[scan_i] <= k[candidate_i]:
						print(d[scan_i], "2 --->>>", d[candidate_i])
						peer_i = scan_i
						peers.append(peer_i)
					else:
						peer_i = candidate_i
						peers.append(peer_i)
						peer_i = scan_i
						peers.append(peer_i)
			break
		if state == ZIG_STATE_START:
			if k[scan_i] >= k[peer_i] * (1 + x):
				print(d[scan_i], "3 --->>>", d[peer_i])
				candidate_i = scan_i
				state = ZIG_STATE_RISE
			elif k[scan_i] <= k[peer_i] * (1 - x):
				print(d[scan_i], "4 --->>>", d[peer_i])
				candidate_i = scan_i
				state = ZIG_STATE_FALL
		elif state == ZIG_STATE_RISE:
			if k[scan_i] >= k[candidate_i]:
				candidate_i = scan_i
			elif k[scan_i] <= k[candidate_i] * (1 - x):
				print(d[scan_i], "5 --->>>", d[candidate_i])
				peer_i = candidate_i
				peers.append(peer_i)
				state = ZIG_STATE_FALL
				candidate_i = scan_i
		elif state == ZIG_STATE_FALL:
			if k[scan_i] <= k[candidate_i]:
				print(d[scan_i], "6 --->>>", d[candidate_i])
				candidate_i = scan_i
			elif k[scan_i] >= k[candidate_i] * (1 + x):
				print(d[scan_i], "7 --->>>", d[candidate_i])
				peer_i = candidate_i
				peers.append(peer_i)
				state = ZIG_STATE_RISE
				candidate_i = scan_i
	for i in range(len(peers) - 1):
		peer_start_i = peers[i]
		peer_end_i = peers[i + 1]
		start_value = k[peer_start_i]
		end_value = k[peer_end_i]
		a = (end_value - start_value) / (peer_end_i - peer_start_i)  # 斜率
		for j in range(peer_end_i - peer_start_i + 1):
			z[j + peer_start_i] = start_value + a * j
	return pd.Series(z), peers


def TROUGHBARS(z, p, m):
	"""
	前 m 个 zig 波谷到当前的距离
	:param z: zig 指标
	:param p: zip 转折点
	:param m: 系数
	:return:
	"""
	trough_bars = np.zeros(len(z))
	if len(z) > 3:
		j = 1
		# 判断第一个是谷还是峰 ,峰则取偶数，如果是谷，则取奇数
		if z[0] > z[1]:
			# 第一个是波谷
			for i in range(len(p)):
				peer = p[i]
				j = i + m * 2
				if 0 < i and len(p) > j and i % 2 == 1:
					num = p[j] - peer - 1
					trough_bars[p[j] - 1] = num
					trough_bars[p[j]] = 1
		if z[0] < z[1]:
			# 第一个是波峰
			for i in range(len(p)):
				peer = p[i]
				j = i + m * 2
				if 0 < i and len(p) > j and i % 2 == 0:
					num = p[j] - peer - 1
					trough_bars[p[j] - 1] = num
					trough_bars[p[j]] = 1
	return pd.Series(trough_bars)


def CROSS(a, b):
	"""
	穿越信号
	当a向上穿越b时，标记1；当a向下穿越b时，标记-1；没穿越标记0
	:param obj:
	:param ref:
	:return:
	"""
	assert len(a) == len(b), '穿越信号输入维度不相等'
	assert len(a) > 1, '穿越信号长度至少为2'
	res = np.zeros(len(a))
	for i in range(len(a) - 2, -1, -1):
		if a[i + 1] <= b[i + 1] and a[i] > b[i] and a[i + 1] < a[i]:
			# 向上穿越时，标记1
			res[i] = 1
		elif a[i + 1] >= b[i + 1] and a[i] < b[i] and a[i + 1] > a[i]:
			res[i] = -1
		else:
			res[i] = 0
	# print(f"a+1 = {a[i + 1]}, b+1 = {b[i + 1]} , a = {a[i]} , b = {b[i]} , res = {res[i]}")
	return pd.Series(res)


def _calc_slope(x):
	return np.polyfit(range(len(x)), x, 1)[0]


def rolling_window(a, window):
	shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
	strides = a.values.strides + (a.values.strides[-1],)
	return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)


def SLOPE(series, n):
	"""
	SLOPE(X,N) 返回线性回归斜率,N支持变量
	参考：https://blog.csdn.net/luhouxiang/article/details/113816062
	"""
	a = rolling_window(series, n)
	obj = np.array([_calc_slope(x) for x in a])
	new_obj = np.pad(obj, (len(series) - len(obj), 0), 'constant', constant_values=(np.nan, np.nan))
	return new_obj


def GOLD_MACD(df_data: pd.DataFrame):
	"""
	黄金MACD指标
	:param df_data:
	:return:
	"""
	df = df_data[::-1].reset_index(drop=True)
	CLOSE = df["close"]
	d = df["trade_date"]
	MACD = (EMA(CLOSE, 30) - REF(EMA(CLOSE, 30), 1)) / REF(EMA(CLOSE, 30), 1) * 100
	DIF = EMA(SUM(MACD, 2), 5)
	buy_1 = DIF > REF(DIF, 1)
	buy_2 = DIF < REF(DIF, 1)

	DEA = MA(DIF, 5)
	return pd.DataFrame(
		{'code': df['ts_code'], 'date': d, 'MACD': MACD, 'DIF': DIF, 'DEA': DEA, 'buy1': buy_1, "buy2": buy_2})


def DJCPX(df_data: pd.DataFrame):
	"""
	顶级操盘线 指标
	:param df_data:
	:return:
	"""
	df = df_data[::-1].reset_index(drop=True)
	k = df["close"]
	d = df["trade_date"]
	# print(f'{d[i]} -->> {buy_1[i]} -->> {buy_2[i]} -->> {B[i]}')
	VAR_200 = round((100 - ((90 * (HHV(df["high"], 20) - df["close"])) / (
			HHV(df["high"], 20) - LLV(df["low"], 20)))), 2)
	VAR_300 = round((100 - MA(
		((100 * (HHV(df["high"], 5) - df["close"])) / (HHV(df["high"], 5) - LLV(df["low"], 5))),
		34)), 2)
	VAR_300_MA_5 = MA(VAR_300, 5)
	# F:IF(CROSS(VAR200,MA(VAR300,5)),LOW * 0.98,DRAWNULL),CROSSDOT,LINETHICK3,COLORFF00FF;
	# CROSS 上穿函数 CROSS(A,B)表示当A从下方向上穿过B时返回1,否则返回0
	F = np.zeros(df.shape[0])
	VAR_CROSS = CROSS(VAR_200, VAR_300_MA_5)
	for i in range(df.shape[0]):
		if VAR_CROSS[i] == 1:
			F[i] = round(df["low"][i] * 0.98, 2)
	# 重心:=(C+0.618*REF(C,1)+0.382*REF(C,1)+0.236*REF(C,3)+0.146*REF(C,4))/2.382;
	ZX = round((k + (0.618 * REF(k, 1)) + (0.382 * REF(k, 1)) + (0.236 * REF(k, 3)) + (
			0.146 * REF(k, 4))) / 2.382, 2)
	# 【操盘线】:EMA(((SLOPE(C,22)*20)+C),55),COLORYELLOW,LINETHICK4;
	CPX = round(EMA(((SLOPE(k, 22) * 20) + k), 55), 2)
	# 【黄金线】:IF(重心>=【操盘线】,【操盘线】,DRAWNULL),COLORRED,LINETHICK2;
	HJX = np.zeros(df.shape[0])
	# 【空仓线】:IF(重心<【操盘线】,【操盘线】,DRAWNULL),COLORCYAN,LINETHICK2;
	KCX = np.zeros(df.shape[0])
	for i in range(df.shape[0]):
		if ZX[i] >= CPX[i]:
			HJX[i] = CPX[i]
		else:
			KCX[i] = CPX[i]
	return pd.DataFrame(
		{'code': df['ts_code'], 'date': d, 'F': F, '黄金线': HJX, '空仓线': KCX})


def CCI(DF, n: int = 14):
	TP = (DF['low'] + DF['high'] + DF['close']) / 3
	MA = TP.rolling(window=n).mean()
	MD = TP.rolling(window=n).apply(lambda x: abs(x - x.mean()).mean(), raw=False)
	return round((TP - MA) / (0.015 * MD), 2)


def bullish(DF, N):
	"""
	多头指标，N项的递增序列
	:param DF:
	:param N:
	:return:
	"""
	return pd.Series.rolling(DF, N).apply(lambda x: x.is_monotonic_increasing)


def bearish(DF, N):
	"""
	空头指标，N项的递减序列
	:param DF:
	:param N:
	:return:
	"""
	return pd.Series.rolling(DF, N).apply(lambda x: x.is_monotonic_decreasing)


def OBV(c, v, M):
	# diff 计算相邻元素的差值
	change = np.diff(c)
	# sign 用于获取数组元素的符号的函数，对于正数，返回 1，对于负数，返回 -1，对于零，返回 0
	# hstack 用于水平（按列）连接数组的函数
	sig = np.hstack([[1], np.sign(change)])
	# cumsum 计算累积和的方法。它将给定数组中的元素逐个累加
	obv_ = np.cumsum(v * sig)
	OBV = pd.Series(obv_)
	MAOBV = MA(OBV, M)
	return pd.DataFrame({'OBV': OBV, 'MAOBV': MAOBV})


def OBV_PLUS(DF, M):
	"""
	OBV策略升级：TODO 还没完成
	1. 增加价格相距大的那一天成交量的权重，这可以更突出上升趋势和下降趋势。
	2. 当天的成交量以一定比例加入OBV中，而不是将全天的成交量全部加入OBV中。
	:param DF:
	:param M:
	:return:
	"""
	CLOSE = DF['close']
	VOL = DF['vol']
	ref = REF(CLOSE, 1)
	var_total = 0
	for index, row in DF.iterrows():
		if np.isnan(ref[index]):
			var_total += VOL[index]
			continue
		if row["close"] > ref[index]:
			vol = VOL[index] * 1
		elif row["close"] == ref[index]:
			vol = 0
		else:
			vol = VOL[index] * -1
		var_total += vol


def ASI(OPEN, CLOSE, HIGH, LOW, M1=26, M2=10):
	"""
	# 振动升降指标
	:param OPEN:
	:param CLOSE:
	:param HIGH:
	:param LOW:
	:param M1:
	:param M2:
	:return:
	"""
	LC = REF(CLOSE, 1)
	AA = ABS(HIGH - LC)
	BB = ABS(LOW - LC)
	CC = ABS(HIGH - REF(LOW, 1))
	DD = ABS(LC - REF(OPEN, 1))
	R = IF((AA > BB) & (AA > CC), AA + BB / 2 + DD / 4, IF((BB > CC) & (BB > AA), BB + AA / 2 + DD / 4, CC + DD / 4))
	X = (CLOSE - LC + (CLOSE - OPEN) / 2 + LC - REF(OPEN, 1))
	SI = 16 * X / R * MAX(AA, BB)
	ASI = SUM(SI, M1)
	ASIT = MA(ASI, M2)
	return {'ASI': ASI, 'ASIT': ASIT}


def DMI(CLOSE, HIGH, LOW, M1=14, M2=6):  # 动向指标：结果和同花顺，通达信完全一致
	TR = SUM(MAX(MAX(HIGH - LOW, ABS(HIGH - REF(CLOSE, 1))), ABS(LOW - REF(CLOSE, 1))), M1)
	HD = HIGH - REF(HIGH, 1)
	LD = REF(LOW, 1) - LOW
	DMP = SUM(IF((HD > 0) & (HD > LD), HD, 0), M1)
	DMM = SUM(IF((LD > 0) & (LD > HD), LD, 0), M1)
	PDI = (DMP * 100) / TR
	MDI = (DMM * 100) / TR
	ADX = MA(ABS(MDI - PDI) / (PDI + MDI) * 100, M2)
	ADXR = (ADX + REF(ADX, M2)) / 2
	return {'PDI': round(PDI.fillna(0), 2), 'MDI': round(MDI.fillna(0), 2), 'ADX': round(ADX.fillna(0), 2),
			'ADXR': round(ADXR.fillna(0), 2)}


def RM_KDJ(C, H, L, N, M1, M2):
	RSV = (C - LLV(L, N)) / (HHV(H, N) - LLV(L, N)) * 100
	K = RM_SMA(RSV, M1, 1)
	D = RM_SMA(K, M2, 1)
	J = 3 * K - 2 * D
	return pd.DataFrame({'KDJ_K': round(K, 2), 'KDJ_D': round(D, 2), 'KDJ_J': round(J, 2)})


def INTPART(number):
	number = number.fillna(0)
	return number.astype(int)


def JXNH(CLOSE, OPEN, VOL):
	VAR1 = MA(CLOSE, 5)
	VAR2 = MA(CLOSE, 10)
	VAR3 = MA(CLOSE, 30)
	VARB = SUM(CLOSE * VOL * 100, 28) / SUM(VOL * 100, 28)
	VARC = INTPART(VARB * 100) / 100
	VARD = EMA(CLOSE, 5) - EMA(CLOSE, 10)
	VARE = EMA(VARD, 9)
	VAR13 = REF(VARE, 1)
	VAR14 = VARE
	VAR15 = VAR14 - VAR13
	VAR16 = REF(VARD, 1)
	VAR17 = VARD
	VAR18 = VAR17 - VAR16
	VAR19 = OPEN
	VAR1A = CLOSE
	JXNH = (VAR19 <= VAR1) & \
		   (VAR19 <= VAR2) & \
		   (VAR19 <= VAR3) & \
		   (VAR1A >= VAR1) & \
		   (VAR1A >= VARC) & (VAR15 > 0) & (VAR18 > 0)
	return pd.DataFrame({'JXNH': JXNH})