def run_once(self):
		wallets = get_wallets()
		my_usd = int(wallets['USD']['Balance']['value_int'])
		my_btc = int(wallets['BTC']['Balance']['value_int'])

		curr_ask = current_ask_price()
		curr_bid = current_bid_price()
		self.prices.append(pd.DataFrame([curr_ask, curr_bid], columns=['ask', 'bid']))
		if pd.rolling_count(self.prices['ask']) < self.lookback:
			print 'only ', pd.rolling_count(self.prices['ask']), ' observations so far'
			return

		means = pd.rolling_mean(self.prices, self.lookback, min_periods = self.lookback)
		stddev = pd.rolling_std(self.prices, self.lookback, min_periods = self.lookback)
		lower = means - stddev
		upper = means + stddev
		normalized = (close - means) / stddev

		timestamps = self.prices.index

		# should we sell? 
		bollinger_ask_now  = normalized['ask'].ix[ldt_timestamps[len(timestamps) - 1]]
		bollinger_ask_last = normalized['ask'].ix[ldt_timestamps[len(timestamps) - 2]]
		if bollinger_ask_now <= -2.0 and bollinger_ask_last >= -2.0:
			print now(), 'begin sell ', my_btc
			print 'sell result', sell(my_btc)

		# should we buy? 
		bollinger_bid_now  = normalized['bid'].ix[ldt_timestamps[len(timestamps) - 1]]
		bollinger_bid_last = normalized['bid'].ix[ldt_timestamps[len(timestamps) - 2]]
		if bollinger_bid_now >= 2.0 and bollinger_bid_last <= 2.0:
			amount = int(my_usd / curr_bid)
			print now(), 'begin buy ', amount
			print 'sell result', buy(amount)
Beispiel #2
0
def a_counter(grouped):
    se = grouped.set_index('ACCIDENT_DT')['DEGREE_INJURY_CD']
    # se is the time series of accident dates restricted to a single MINE_ID
    se = se.resample("D")
    df = pd.DataFrame({'degree_injury_cd':se, 'a90':pd.rolling_count(se, 90), 'a30':pd.rolling_count(se, 30)})
    # TODO: include a sum of injury counts by day
    return df
Beispiel #3
0
 def test_filter_1(self):
     df = self.fetcher.fetch_window('close', DATES[self.si-window: self.ei+1])
     df = pd.rolling_sum(df.fillna(0), window) > 2 * pd.rolling_count(df, window)
     df1 = df.shift(1).iloc[window:].astype(bool)
     df2 = self.filter.filter(self.startdate, self.enddate)
     print 'bm', df1.sum(axis=1)
     self.assertTrue(frames_equal(df1, df2))
Beispiel #4
0
def rolling_functions_tests(p, d):
    # Old-fashioned rolling API
    assert_eq(pd.rolling_count(p, 3), dd.rolling_count(d, 3))
    assert_eq(pd.rolling_sum(p, 3), dd.rolling_sum(d, 3))
    assert_eq(pd.rolling_mean(p, 3), dd.rolling_mean(d, 3))
    assert_eq(pd.rolling_median(p, 3), dd.rolling_median(d, 3))
    assert_eq(pd.rolling_min(p, 3), dd.rolling_min(d, 3))
    assert_eq(pd.rolling_max(p, 3), dd.rolling_max(d, 3))
    assert_eq(pd.rolling_std(p, 3), dd.rolling_std(d, 3))
    assert_eq(pd.rolling_var(p, 3), dd.rolling_var(d, 3))
    # see note around test_rolling_dataframe for logic concerning precision
    assert_eq(pd.rolling_skew(p, 3),
              dd.rolling_skew(d, 3), check_less_precise=True)
    assert_eq(pd.rolling_kurt(p, 3),
              dd.rolling_kurt(d, 3), check_less_precise=True)
    assert_eq(pd.rolling_quantile(p, 3, 0.5), dd.rolling_quantile(d, 3, 0.5))
    assert_eq(pd.rolling_apply(p, 3, mad), dd.rolling_apply(d, 3, mad))
    with ignoring(ImportError):
        assert_eq(pd.rolling_window(p, 3, 'boxcar'),
                  dd.rolling_window(d, 3, 'boxcar'))
    # Test with edge-case window sizes
    assert_eq(pd.rolling_sum(p, 0), dd.rolling_sum(d, 0))
    assert_eq(pd.rolling_sum(p, 1), dd.rolling_sum(d, 1))
    # Test with kwargs
    assert_eq(pd.rolling_sum(p, 3, min_periods=3),
              dd.rolling_sum(d, 3, min_periods=3))
def collection_freq(breath_df, win):
    print(breath_df.columns)
    for ds_type in ['ds', 'pl', 'pvt', 'ie']:
        breath_df['{0}_rolling'.format(ds_type)] = pd.rolling_sum(breath_df['analysis.' + ds_type], window = 60 * win,
                                                                  center = True, min_periods = 1)
        breath_df[ds_type + '_tot_rolling'] = pd.rolling_count(breath_df['analysis.' + ds_type], window = 60 * win,
                                                               center = True)
        breath_df[ds_type + '_freq'] = breath_df[ds_type + '_rolling'] / breath_df[ds_type + '_tot_rolling']

    # add rolling average for Fio2, PEEP, p_mean
    try:
        breath_df['peep_rolling'] = pd.rolling_mean(breath_df['vent_settings.PEEP'], window = 60 * win,
                                                    center = True, min_periods = 1)
    except KeyError:
        pass

    try:
        breath_df['p_mean_rolling'] = pd.rolling_mean(breath_df['vent_settings.p_mean'], window = 60 * win,
                                                      center = True, min_periods = 1)
    except KeyError:
        pass

    try:
        breath_df['fio2_rolling'] = pd.rolling_mean(breath_df['vent_settings.FiO2'], window = 60 * win,
                                                    center = True, min_periods = 1)
    except KeyError:
        pass

    return breath_df
    def rollingStats(self, selectCol = [], splitCol=None, sepCol=None, startTime=None, endTime=None, window=60, quantile=0.1, freq='10s', min_periods=5 ):
        
        df = self.dfSetup()
        
        ## Selects a list of columns to use and splits a column into single type if it contains more than one
        # eg. if a file contains multiple sensor readings 
        if (len(selectCol) > 0):
            dfSub = df[selectCol]
            
        else:
            dfSub = df
        
        if (splitCol and sepCol):
            dfSub = dfSub[dfSub[splitCol] == sepCol]
        
        ## Converts datetime column to datatime object index, then use it to create time slices
        # Time format '2015-10-17 09:00:00' May use the dfOther to use other data frames
        if (startTime and endTime):
            dfSub = dfSub[ startTime : endTime ]
        
        else:
            dfSub = dfSub
        
        if (splitCol):
            dfSub = dfSub.drop(splitCol, axis=1) # Remove columns used to split entries
        
        
        valueName = dfSub.columns.values[0]
        outList = []
        
        counts = pd.rolling_count(dfSub,window,freq=freq).rename(columns = {valueName:'rolling_counts'})
        outList.append(counts)
        
        means = pd.rolling_mean(dfSub, window, min_periods=min_periods, freq=freq).rename(columns = {valueName:'rolling_mean'})
        outList.append(means)
        
        rms = np.sqrt(pd.rolling_mean(dfSub**2, window, min_periods=min_periods, freq=freq).rename(columns = {valueName:'rolling_rms'}) )
        outList.append(rms)
        
        medians = pd.rolling_median(dfSub, window, min_periods=min_periods, freq=freq).rename(columns = {valueName:'rolling_median'})
        outList.append(medians)
        
        stds = pd.rolling_std(dfSub, window, min_periods=min_periods, freq=freq).rename(columns = {valueName:'rolling_std'})
        outList.append(stds)
        
        mins = pd.rolling_min(dfSub, window, min_periods=min_periods, freq=freq).rename(columns = {valueName:'rolling_min'})
        outList.append(mins)
        
        maxs = pd.rolling_max(dfSub, window, min_periods=min_periods, freq=freq).rename(columns = {valueName:'rolling_max'})
        outList.append(maxs)
        
        quants = pd.rolling_quantile(dfSub, window, quantile, min_periods=min_periods, freq=freq).rename(columns = {valueName:'rolling_quantile'})
        outList.append(quants)

        
        dfOut = pd.concat(outList, axis=1)

        return dfOut
Beispiel #7
0
 def test_filter_2(self):
     df = self.fetcher.fetch_window('close', DATES[self.si-window: self.ei+1])
     parent = df.notnull()
     df = df.shift(1)
     df[~parent] = None
     df = pd.rolling_sum(df.fillna(0), window) > 2 * pd.rolling_count(df, window)
     df[~parent] = False
     df = df.iloc[window:]
     self.assertTrue(frames_equal(df, self.filter.filter(self.startdate, self.enddate, parent)))
Beispiel #8
0
def calc_stats(timestamps,
               gain,
               pol='no polarizarion',
               windowtime=1200,
               minsamples=1):
    """ calculate the Stats needed to evaluate the obsevation"""
    returntext = []
    gain_ts = pandas.Series(gain,
                            pandas.to_datetime(np.round(timestamps),
                                               unit='s')).asfreq(freq='1s')
    mean = pandas.rolling_mean(gain_ts, windowtime, minsamples)
    std = pandas.rolling_std(gain_ts, windowtime, minsamples)
    windowgainchange = std / mean * 100
    dtrend_std = pandas.rolling_apply(gain_ts, windowtime, detrend, minsamples)
    #trend_std = pandas.rolling_apply(ts,5,lambda x : np.ma.std(x-(np.arange(x.shape[0])*np.ma.polyfit(np.arange(x.shape[0]),x,1)[0])),1)
    detrended_windowgainchange = dtrend_std / mean * 100
    timeval = timestamps.max() - timestamps.min()
    window_occ = pandas.rolling_count(gain_ts, windowtime) / float(windowtime)

    #rms = np.sqrt((gain**2).mean())
    returntext.append(
        "Total time of obsevation : %f (seconds) with %i accumulations." %
        (timeval, timestamps.shape[0]))
    #returntext.append("The mean gain of %s is: %.5f"%(pol,gain.mean()))
    #returntext.append("The Std. dev of the gain of %s is: %.5f"%(pol,gain.std()))
    #returntext.append("The RMS of the gain of %s is : %.5f"%(pol,rms))
    #returntext.append("The Percentage variation of %s is: %.5f"%(pol,gain.std()/gain.mean()*100))
    returntext.append(
        "The mean Percentage variation over %i seconds of %s is: %.5f    (req < 2 )"
        % (windowtime, pol, windowgainchange.mean()))
    returntext.append(
        "The Max  Percentage variation over %i seconds of %s is: %.5f    (req < 2 )"
        % (windowtime, pol, windowgainchange.max()))
    returntext.append(
        "The mean detrended Percentage variation over %i seconds of %s is: %.5f    (req < 2 )"
        % (windowtime, pol, detrended_windowgainchange.mean()))
    returntext.append(
        "The Max  detrended Percentage variation over %i seconds of %s is: %.5f    (req < 2 )"
        % (windowtime, pol, detrended_windowgainchange.max()))
    #a - np.round(np.polyfit(b,a.T,1)[0,:,np.newaxis]*b + np.polyfit(b,a.T,1)[1,:,np.newaxis])

    pltobj = plt.figure()
    plt.title('Percentage Variation of %s pol, %i Second sliding Window' % (
        pol,
        windowtime,
    ))
    windowgainchange.plot(label='Orignal')
    detrended_windowgainchange.plot(label='Detrended')
    window_occ.plot(label='Window Occupancy')
    plt.hlines(2, timestamps.min(), timestamps.max(), colors='k')
    plt.ylabel('Percentage Variation')
    plt.xlabel('Date/Time')
    plt.legend(loc='best')
    #plt.title(" %s pol Gain"%(pol))
    #plt.plot(windowgainchange.mean(),'b',label='20 Min (std/mean)')
    #plt.plot(np.ones_like(windowgainchange.mean())*2.0,'r',label=' 2 level')
    return returntext, pltobj  # a plot would be cool
Beispiel #9
0
 def test_filter_1(self):
     df = self.fetcher.fetch_window('close',
                                    DATES[self.si - window:self.ei + 1])
     df = pd.rolling_sum(df.fillna(0),
                         window) > 2 * pd.rolling_count(df, window)
     df1 = df.shift(1).iloc[window:].astype(bool)
     df2 = self.filter.filter(self.startdate, self.enddate)
     print 'bm', df1.sum(axis=1)
     self.assertTrue(frames_equal(df1, df2))
Beispiel #10
0
 def test_filter_2(self):
     df = self.fetcher.fetch_window('close',
                                    DATES[self.si - window:self.ei + 1])
     parent = df.notnull()
     df = df.shift(1)
     df[~parent] = None
     df = pd.rolling_sum(df.fillna(0),
                         window) > 2 * pd.rolling_count(df, window)
     df[~parent] = False
     df = df.iloc[window:]
     self.assertTrue(
         frames_equal(
             df, self.filter.filter(self.startdate, self.enddate, parent)))
Beispiel #11
0
def rolling_tests(p, d):
    eq(pd.rolling_count(p, 3), dd.rolling_count(d, 3))
    eq(pd.rolling_sum(p, 3), dd.rolling_sum(d, 3))
    eq(pd.rolling_mean(p, 3), dd.rolling_mean(d, 3))
    eq(pd.rolling_median(p, 3), dd.rolling_median(d, 3))
    eq(pd.rolling_min(p, 3), dd.rolling_min(d, 3))
    eq(pd.rolling_max(p, 3), dd.rolling_max(d, 3))
    eq(pd.rolling_std(p, 3), dd.rolling_std(d, 3))
    eq(pd.rolling_var(p, 3), dd.rolling_var(d, 3))
    eq(pd.rolling_skew(p, 3), dd.rolling_skew(d, 3))
    eq(pd.rolling_kurt(p, 3), dd.rolling_kurt(d, 3))
    eq(pd.rolling_quantile(p, 3, 0.5), dd.rolling_quantile(d, 3, 0.5))
    mad = lambda x: np.fabs(x - x.mean()).mean()
    eq(pd.rolling_apply(p, 3, mad), dd.rolling_apply(d, 3, mad))
    eq(pd.rolling_window(p, 3, 'boxcar'), dd.rolling_window(d, 3, 'boxcar'))
    # Test with edge-case window sizes
    eq(pd.rolling_sum(p, 0), dd.rolling_sum(d, 0))
    eq(pd.rolling_sum(p, 1), dd.rolling_sum(d, 1))
    # Test with kwargs
    eq(pd.rolling_sum(p, 3, min_periods=3), dd.rolling_sum(d, 3, min_periods=3))
Beispiel #12
0
def rolling_functions_tests(p, d):
    # Old-fashioned rolling API
    eq(pd.rolling_count(p, 3), dd.rolling_count(d, 3))
    eq(pd.rolling_sum(p, 3), dd.rolling_sum(d, 3))
    eq(pd.rolling_mean(p, 3), dd.rolling_mean(d, 3))
    eq(pd.rolling_median(p, 3), dd.rolling_median(d, 3))
    eq(pd.rolling_min(p, 3), dd.rolling_min(d, 3))
    eq(pd.rolling_max(p, 3), dd.rolling_max(d, 3))
    eq(pd.rolling_std(p, 3), dd.rolling_std(d, 3))
    eq(pd.rolling_var(p, 3), dd.rolling_var(d, 3))
    eq(pd.rolling_skew(p, 3), dd.rolling_skew(d, 3))
    eq(pd.rolling_kurt(p, 3), dd.rolling_kurt(d, 3))
    eq(pd.rolling_quantile(p, 3, 0.5), dd.rolling_quantile(d, 3, 0.5))
    eq(pd.rolling_apply(p, 3, mad), dd.rolling_apply(d, 3, mad))
    with ignoring(ImportError):
        eq(pd.rolling_window(p, 3, 'boxcar'), dd.rolling_window(d, 3, 'boxcar'))
    # Test with edge-case window sizes
    eq(pd.rolling_sum(p, 0), dd.rolling_sum(d, 0))
    eq(pd.rolling_sum(p, 1), dd.rolling_sum(d, 1))
    # Test with kwargs
    eq(pd.rolling_sum(p, 3, min_periods=3), dd.rolling_sum(d, 3, min_periods=3))
Beispiel #13
0
def rolling_functions_tests(p, d):
    # Old-fashioned rolling API
    eq(pd.rolling_count(p, 3), dd.rolling_count(d, 3))
    eq(pd.rolling_sum(p, 3), dd.rolling_sum(d, 3))
    eq(pd.rolling_mean(p, 3), dd.rolling_mean(d, 3))
    eq(pd.rolling_median(p, 3), dd.rolling_median(d, 3))
    eq(pd.rolling_min(p, 3), dd.rolling_min(d, 3))
    eq(pd.rolling_max(p, 3), dd.rolling_max(d, 3))
    eq(pd.rolling_std(p, 3), dd.rolling_std(d, 3))
    eq(pd.rolling_var(p, 3), dd.rolling_var(d, 3))
    eq(pd.rolling_skew(p, 3), dd.rolling_skew(d, 3))
    eq(pd.rolling_kurt(p, 3), dd.rolling_kurt(d, 3))
    eq(pd.rolling_quantile(p, 3, 0.5), dd.rolling_quantile(d, 3, 0.5))
    eq(pd.rolling_apply(p, 3, mad), dd.rolling_apply(d, 3, mad))
    with ignoring(ImportError):
        eq(pd.rolling_window(p, 3, "boxcar"), dd.rolling_window(d, 3, "boxcar"))
    # Test with edge-case window sizes
    eq(pd.rolling_sum(p, 0), dd.rolling_sum(d, 0))
    eq(pd.rolling_sum(p, 1), dd.rolling_sum(d, 1))
    # Test with kwargs
    eq(pd.rolling_sum(p, 3, min_periods=3), dd.rolling_sum(d, 3, min_periods=3))
Beispiel #14
0
def rolling_tests(p, d):
    eq(pd.rolling_count(p, 3), dd.rolling_count(d, 3))
    eq(pd.rolling_sum(p, 3), dd.rolling_sum(d, 3))
    eq(pd.rolling_mean(p, 3), dd.rolling_mean(d, 3))
    eq(pd.rolling_median(p, 3), dd.rolling_median(d, 3))
    eq(pd.rolling_min(p, 3), dd.rolling_min(d, 3))
    eq(pd.rolling_max(p, 3), dd.rolling_max(d, 3))
    eq(pd.rolling_std(p, 3), dd.rolling_std(d, 3))
    eq(pd.rolling_var(p, 3), dd.rolling_var(d, 3))
    eq(pd.rolling_skew(p, 3), dd.rolling_skew(d, 3))
    eq(pd.rolling_kurt(p, 3), dd.rolling_kurt(d, 3))
    eq(pd.rolling_quantile(p, 3, 0.5), dd.rolling_quantile(d, 3, 0.5))
    mad = lambda x: np.fabs(x - x.mean()).mean()
    eq(pd.rolling_apply(p, 3, mad), dd.rolling_apply(d, 3, mad))
    with ignoring(ImportError):
        eq(pd.rolling_window(p, 3, 'boxcar'),
           dd.rolling_window(d, 3, 'boxcar'))
    # Test with edge-case window sizes
    eq(pd.rolling_sum(p, 0), dd.rolling_sum(d, 0))
    eq(pd.rolling_sum(p, 1), dd.rolling_sum(d, 1))
    # Test with kwargs
    eq(pd.rolling_sum(p, 3, min_periods=3), dd.rolling_sum(d, 3,
                                                           min_periods=3))
Beispiel #15
0
def rolling_functions_tests(p, d):
    # Old-fashioned rolling API
    eq(pd.rolling_count(p, 3), dd.rolling_count(d, 3))
    eq(pd.rolling_sum(p, 3), dd.rolling_sum(d, 3))
    eq(pd.rolling_mean(p, 3), dd.rolling_mean(d, 3))
    eq(pd.rolling_median(p, 3), dd.rolling_median(d, 3))
    eq(pd.rolling_min(p, 3), dd.rolling_min(d, 3))
    eq(pd.rolling_max(p, 3), dd.rolling_max(d, 3))
    eq(pd.rolling_std(p, 3), dd.rolling_std(d, 3))
    eq(pd.rolling_var(p, 3), dd.rolling_var(d, 3))
    # see note around test_rolling_dataframe for logic concerning precision
    eq(pd.rolling_skew(p, 3), dd.rolling_skew(d, 3), check_less_precise=True)
    eq(pd.rolling_kurt(p, 3), dd.rolling_kurt(d, 3), check_less_precise=True)
    eq(pd.rolling_quantile(p, 3, 0.5), dd.rolling_quantile(d, 3, 0.5))
    eq(pd.rolling_apply(p, 3, mad), dd.rolling_apply(d, 3, mad))
    with ignoring(ImportError):
        eq(pd.rolling_window(p, 3, 'boxcar'),
           dd.rolling_window(d, 3, 'boxcar'))
    # Test with edge-case window sizes
    eq(pd.rolling_sum(p, 0), dd.rolling_sum(d, 0))
    eq(pd.rolling_sum(p, 1), dd.rolling_sum(d, 1))
    # Test with kwargs
    eq(pd.rolling_sum(p, 3, min_periods=3), dd.rolling_sum(d, 3,
                                                           min_periods=3))
Beispiel #16
0
def r_count_window(df, windows_size):
    return rolling_count(df, windows_size)
 def count_nans(self, x, n):
     return n - pd.rolling_count(x, n)
Beispiel #18
0
 def func(window):
     return lambda df: pd.rolling_sum(df.fillna(0), window) >= x * pd.rolling_count(df, window)
Beispiel #19
0
 def func(window):
     return lambda df: \
             (pd.rolling_sum(df.fillna(0), window)/pd.rolling_count(df, window)).\
             rank(axis=1, ascending=ascending) <= x
Beispiel #20
0
 def rolling_smoother(self, data, stype='rolling_mean', win_size=10, win_type='boxcar', center=False, std=0.1,
                      beta=0.1,
                      power=1, width=1):
     """
     
     Perform a espanding smooting on the data for a complete help refer to http://pandas.pydata.org/pandas-docs/dev/computation.html
     
     :param data:
     :param stype:
     :param win_size:
     :param win_type:
     :param center:
     :param std:
     :param beta:
     :param power:
     :param width:
     :moothing types:
         ROLLING :
             rolling_count	Number of non-null observations
             rolling_sum	Sum of values
             rolling_mean	Mean of values
             rolling_median	Arithmetic median of values
             rolling_min	Minimum
             rolling_max	Maximum
             rolling_std	Unbiased standard deviation
             rolling_var	Unbiased variance
             rolling_skew	Unbiased skewness (3rd moment)
             rolling_kurt	Unbiased kurtosis (4th moment)
             rolling_window	Moving window function
                 window types:
                     boxcar
                     triang
                     blackman
                     hamming
                     bartlett
                     parzen
                     bohman
                     blackmanharris
                     nuttall
                     barthann
                     kaiser (needs beta)
                     gaussian (needs std)
                     general_gaussian (needs power, width)
                     slepian (needs width)
     
     """
     if stype == 'count':
         newy = pd.rolling_count(data, win_size)
     if stype == 'sum':
         newy = pd.rolling_sum(data, win_size)
     if stype == 'mean':
         newy = pd.rolling_mean(data, win_size)
     if stype == 'median':
         newy = pd.rolling_median(data, win_size)
     if stype == 'min':
         newy = pd.rolling_min(data, win_size)
     if stype == 'max':
         newy = pd.rolling_max(data, win_size)
     if stype == 'std':
         newy = pd.rolling_std(data, win_size)
     if stype == 'var':
         newy = pd.rolling_var(data, win_size)
     if stype == 'skew':
         newy = pd.rolling_skew(data, win_size)
     if stype == 'kurt':
         newy = pd.rolling_kurt(data, win_size)
     if stype == 'window':
         if win_type == 'kaiser':
             newy = pd.rolling_window(data, win_size, win_type, center=center, beta=beta)
         if win_type == 'gaussian':
             newy = pd.rolling_window(data, win_size, win_type, center=center, std=std)
         if win_type == 'general_gaussian':
             newy = pd.rolling_window(data, win_size, win_type, center=center, power=power, width=width)
         else:
             newy = pd.rolling_window(data, win_size, win_type, center=center)
     return newy
Beispiel #21
0
 def func(window):
     return lambda df: pd.rolling_count(df, window) >= x * window * 0.01
def ts_countFn(arr, max_periods):
    if not (max_periods): max_periods = len(arr)
    return pd.rolling_count(arr, max_periods)
Beispiel #23
0
 def evaluate(self, table):
     expr = self.expr
     val = None
     if expr is not None:
         val = expr.evaluate(table)
     return pd.rolling_count(val, self.window)
Beispiel #24
0
 def func(window):
     return lambda df: \
             (pd.rolling_sum(df.fillna(0), window)/pd.rolling_count(df, window)).\
             rank(axis=1, ascending=ascending) <= x
Beispiel #25
0
 def func(window):
     return lambda df: pd.rolling_count(df, window) >= x * window * 0.01
Beispiel #26
0
 def func(window):
     return lambda df: \
             (pd.rolling_sum(df.fillna(0), window)/pd.rolling_count(df, window)).\
             rank(axis=1, ascending=ascending).\
             div(df.fillna(method='ffill', limit=window).count(axis=1), axis=0) <= x * 0.01
 def rolling_count(self, *args, **kwargs):
     return MySeries(pd.rolling_count(self.x, *args, **kwargs))
Beispiel #28
0
 def count_nans(self, x, n):
     return n - pd.rolling_count(x, n)
 def make_busd_column(dataframe,mins_prior):
     column_name = '%s_min_busd' % mins_prior
     successfully_made_column = False
     while not successfully_made_column:        
         dataframe[column_name] = pd.rolling_sum(dataframe.busd,mins_prior, freq='T', min_periods = 1) / pd.rolling_count(dataframe.busd,mins_prior, freq='T')
         successfully_made_column = assess_column(dataframe, column_name)
Beispiel #30
0
 def func(window):
     return lambda df: pd.rolling_sum(df.fillna(0), window
                                      ) <= x * pd.rolling_count(df, window)
Beispiel #31
0
def i_counter(grouped):
    se = grouped.set_index('INSPECTION_BEGIN_DT')['EVENT_NO']
    # se is the time series of inspection dates restricted to a single MINE_ID
    se = se.resample("D")
    df = pd.DataFrame({'event_no':se, 'i90':pd.rolling_count(se, 90), 'i30':pd.rolling_count(se, 30)})
    return df
Beispiel #32
0
 def func(window):
     return lambda df: \
             (pd.rolling_sum(df.fillna(0), window)/pd.rolling_count(df, window)).\
             rank(axis=1, ascending=ascending).\
             div(df.fillna(method='ffill', limit=window).count(axis=1), axis=0) <= x * 0.01