我们从Python开源项目中，提取了以下26个代码示例，用于说明如何使用pandas.rolling_sum()。
def KST(df, r1, r2, r3, r4, n1, n2, n3, n4): M = df['close'].diff(r1 - 1) N = df['close'].shift(r1 - 1) ROC1 = M / N M = df['close'].diff(r2 - 1) N = df['close'].shift(r2 - 1) ROC2 = M / N M = df['close'].diff(r3 - 1) N = df['close'].shift(r3 - 1) ROC3 = M / N M = df['close'].diff(r4 - 1) N = df['close'].shift(r4 - 1) ROC4 = M / N KST = pd.Series(pd.rolling_sum(ROC1, n1) + pd.rolling_sum(ROC2, n2) * 2 + pd.rolling_sum(ROC3, n3) * 3 + pd.rolling_sum(ROC4, n4) * 4, name = 'KST' + str(r1) + '_' + str(r2) + '_' + str(r3) + '_' + str(r4) + '_' + str(n1) + '_' + str(n2) + '_' + str(n3) + '_' + str(n4)) return KST #Relative Strength Index
def SVAPO(df, period = 8, cutoff = 1, stdev_h = 1.5, stdev_l = 1.3, stdev_period = 100): HA = HEIKEN_ASHI(df, 1) haCl = (HA.HAopen + HA.HAclose + HA.HAhigh + HA.HAlow)/4.0 haC = TEMA( haCl, 0.625 * period ) vave = MA(df, 5 * period, field = 'volume').shift(1) vc = pd.concat([df['volume'], vave*2], axis=1).min(axis=1) vtrend = TEMA(LINEAR_REG_SLOPE(df.volume, period), period) UpD = pd.Series(vc) DoD = pd.Series(-vc) UpD[(haC<=haC.shift(1)*(1+cutoff/1000.0))|(vtrend < vtrend.shift(1))] = 0 DoD[(haC>=haC.shift(1)*(1-cutoff/1000.0))|(vtrend > vtrend.shift(1))] = 0 delta_sum = pd.rolling_sum(UpD + DoD, period)/(vave+1) svapo = pd.Series(TEMA(delta_sum, period), name = 'SVAPO_%s' % period) svapo_std = pd.rolling_std(svapo, stdev_period) svapo_ub = pd.Series(svapo_std * stdev_h, name = 'SVAPO_UB%s' % period) svapo_lb = pd.Series(-svapo_std * stdev_l, name = 'SVAPO_LB%s' % period) return pd.concat([svapo, svapo_ub, svapo_lb], join='outer', axis=1)
def Vortex(df, n): i = 0 TR = [0] while i < df.index[-1]: Range = max(df.get_value(i + 1, 'High'), df.get_value(i, 'Close')) - min(df.get_value(i + 1, 'Low'), df.get_value(i, 'Close')) TR.append(Range) i = i + 1 i = 0 VM = [0] while i < df.index[-1]: Range = abs(df.get_value(i + 1, 'High') - df.get_value(i, 'Low')) - abs(df.get_value(i + 1, 'Low') - df.get_value(i, 'High')) VM.append(Range) i = i + 1 VI = pd.Series(pd.rolling_sum(pd.Series(VM), n) / pd.rolling_sum(pd.Series(TR), n), name = 'Vortex_' + str(n)) df = df.join(VI) return df #KST Oscillator
def KST(df, r1, r2, r3, r4, n1, n2, n3, n4): M = df['Close'].diff(r1 - 1) N = df['Close'].shift(r1 - 1) ROC1 = M / N M = df['Close'].diff(r2 - 1) N = df['Close'].shift(r2 - 1) ROC2 = M / N M = df['Close'].diff(r3 - 1) N = df['Close'].shift(r3 - 1) ROC3 = M / N M = df['Close'].diff(r4 - 1) N = df['Close'].shift(r4 - 1) ROC4 = M / N KST = pd.Series(pd.rolling_sum(ROC1, n1) + pd.rolling_sum(ROC2, n2) * 2 + pd.rolling_sum(ROC3, n3) * 3 + pd.rolling_sum(ROC4, n4) * 4, name = 'KST_' + str(r1) + '_' + str(r2) + '_' + str(r3) + '_' + str(r4) + '_' + str(n1) + '_' + str(n2) + '_' + str(n3) + '_' + str(n4)) df = df.join(KST) return df #Relative Strength Index
def getRSI(close): ''' calculate RSI value :param DataFrame close: close price :return: DataFrame RSI: RSI value ''' n = 3 # calculate increment of close price of two succeeding days close_increment = close.diff() close_increment.dropna(inplace=True) close_increment.index = range(close_increment.shape[0]) close_pos = close_increment.copy() close_pos[close_pos < 0] = 0 close_abs = np.abs(close_increment) sum_pos = pd.rolling_sum(close_pos, n) sum_pos.dropna(inplace=True) sum_pos.index = range(sum_pos.shape[0]) sum_abs = pd.rolling_sum(close_abs, n) sum_abs.dropna(inplace=True) sum_abs.index = range(sum_abs.shape[0]) RSI = sum_pos / sum_abs RSI.replace([np.nan, np.inf,-np.inf], 0, inplace=True) return RSI
def SUM(self, param): if param[1] == 0: return pd.expanding_sum(param[0]) return pd.rolling_sum(param[0], param[1])
def EVERY(self, param): norm = self.IF([param[0], 1, 0]) result = pd.rolling_sum(norm, param[1]) return result == param[1]
def EXIST(self, param): norm = self.IF([param[0], 1, 0]) result = pd.rolling_sum(norm, param[1]) return result > 0
def COUNT(self, param): norm = self.IF([param[0], 1, 0]) result = pd.rolling_sum(norm, param[1]) return result
def INSIST(self, param): norm = self.IF([param[0], 1, 0]) x1 = pd.rolling_sum(norm, param[1]) x2 = pd.rolling_sum(norm, param[2]) ret =((x1 - x2) == np.abs(param[1] - param[2])) return ret
def MassI(df): Range = df['high'] - df['low'] EX1 = pd.ewma(Range, span = 9, min_periods = 8) EX2 = pd.ewma(EX1, span = 9, min_periods = 8) Mass = EX1 / EX2 MassI = pd.Series(pd.rolling_sum(Mass, 25), name = 'MassIndex') return MassI #Vortex Indicator
def Vortex(df, n): tr = TR(df) vm = abs(df['high'] - df['low'].shift(1)) - abs(df['low']-df['high'].shift(1)) VI = pd.Series(pd.rolling_sum(vm, n) / pd.rolling_sum(tr, n), name = 'Vortex' + str(n)) return VI #KST Oscillator
def ULTOSC(df): TR_l = TR(df) BP_l = df['close'] - pd.concat([df['low'], df['close'].shift(1)], axis=1).min(axis=1) UltO = pd.Series((4 * pd.rolling_sum(BP_l, 7) / pd.rolling_sum(TR_l, 7)) + (2 * pd.rolling_sum(BP_l, 14) / pd.rolling_sum(TR_l, 14)) + (pd.rolling_sum(BP_l, 28) / pd.rolling_sum(TR_l, 28)), name = 'UltOsc') return UltO
def MassI(df): Range = df['High'] - df['Low'] EX1 = pd.ewma(Range, span = 9, min_periods = 8) EX2 = pd.ewma(EX1, span = 9, min_periods = 8) Mass = EX1 / EX2 MassI = pd.Series(pd.rolling_sum(Mass, 25), name = 'Mass Index') df = df.join(MassI) return df #Vortex Indicator: http://www.vortexindicator.com/VFX_VORTEX.PDF
def ULTOSC(df): i = 0 TR_l = [0] BP_l = [0] while i < df.index[-1]: TR = max(df.get_value(i + 1, 'High'), df.get_value(i, 'Close')) - min(df.get_value(i + 1, 'Low'), df.get_value(i, 'Close')) TR_l.append(TR) BP = df.get_value(i + 1, 'Close') - min(df.get_value(i + 1, 'Low'), df.get_value(i, 'Close')) BP_l.append(BP) i = i + 1 UltO = pd.Series((4 * pd.rolling_sum(pd.Series(BP_l), 7) / pd.rolling_sum(pd.Series(TR_l), 7)) + (2 * pd.rolling_sum(pd.Series(BP_l), 14) / pd.rolling_sum(pd.Series(TR_l), 14)) + (pd.rolling_sum(pd.Series(BP_l), 28) / pd.rolling_sum(pd.Series(TR_l), 28)), name = 'Ultimate_Osc') df = df.join(UltO) return df #Donchian Channel
def _roll_exp(self, sample): ts = sample result = pd.DataFrame([], index=ts.index.rename("time")) for key, value in self._column_names["M"].items(): result[value[0]] = pd.rolling_sum(ts, key).apply(self.calculator_arithmetic_mean, axis=1) return result
def ar_window_compound(self): ts = self.pnl_compound_ratio("MS") result = pd.DataFrame([], index=ts.index.rename("time")) for key, value in self._column_names["M"].items(): result[value[0]] = pd.rolling_sum(ts, key).apply(self.calculator_arithmetic_mean, axis=1) return result
def getKDJ(close, high, low): ''' calculate KDJ value :param DataFrame close:close price :param DataFrame high:highest price of a day :param DataFrame low: lowest price of a day :return: [DataFrame,DataFrame,DataFrame,DataFrame] [RSV, K, D, KDJ]:KDJ value and some subproducts ''' # interval over which KDJ is calculated kdj_interval = 9 N = 3 # calculate RSV # get the close value to be used close = pd.DataFrame(close.iloc[(kdj_interval - 1):, :].values) # calculate maximum in (kdj_interval) days in high value high_max_in_interval = pd.rolling_max(high, kdj_interval) # rolling_sum function will set the first (kdj_interval-1) days as np.nan,drop them high_max_in_interval.dropna(inplace=True) # set index with 0,1,2...,otherwise it will be kdj_interval,kdj_interval+1,...(may not be explicit but fuck the index) high_max_in_interval.index = range(high_max_in_interval.shape[0]) low_min_in_interval = pd.rolling_min(low, kdj_interval) low_min_in_interval.dropna(inplace=True) low_min_in_interval.index = range(low_min_in_interval.shape[0]) # calculate RSV RSV = 100 * (close - low_min_in_interval) / (high_max_in_interval - low_min_in_interval) # replace np.nan and np.inf in RSV because there might be 0 in the denominator of the last formula RSV.replace([np.nan, np.inf,-np.inf], 0, inplace=True) # get matrix shape [row, col] = RSV.shape # calculate K # assuming N equals n in the formula # initialize both N and K with 50 K = pd.DataFrame(np.zeros([row, col])) D = pd.DataFrame(np.zeros([row, col])) K.iloc[0, :] = 50 * np.ones([1, col]) D.iloc[0, :] = 50 * np.ones([1, col]) # calculate K and D iteratively for i in range(1, row): K.iloc[i, :] = (RSV.iloc[i, :] + K.iloc[(i - 1), :]) / N D.iloc[i, :] = (K.iloc[i, :] - D.iloc[(i - 1), :]) / N KDJ = 3 * K - 2 * D return [RSV, K, D, KDJ]
