neulab/docprompting-conala huggingface dataset:
pandas.core.resample.Resampler.sum   Resampler.sum(_method='sum', min_count=0, *args, **kwargs)[source]
 
Compute sum of group values.  Parameters 
 
numeric_only:bool, default True


Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data.  
min_count:int, default 0


The required number of valid values to perform the operation. If fewer than min_count non-NA values are present the result will be NA.    Returns 
 Series or DataFrame

Computed sum of values within each group.
pandas.core.resample.Resampler.transform   Resampler.transform(arg, *args, **kwargs)[source]
 
Call function producing a like-indexed Series on each group and return a Series with the transformed values.  Parameters 
 
arg:function


To apply to each group. Should return a Series with the same index.    Returns 
 
transformed:Series

   Examples 
>>> s = pd.Series([1, 2],
...               index=pd.date_range('20180101',
...                                   periods=2,
...                                   freq='1h'))
>>> s
2018-01-01 00:00:00    1
2018-01-01 01:00:00    2
Freq: H, dtype: int64
  
>>> resampled = s.resample('15min')
>>> resampled.transform(lambda x: (x - x.mean()) / x.std())
2018-01-01 00:00:00   NaN
2018-01-01 01:00:00   NaN
Freq: H, dtype: float64
pandas.core.resample.Resampler.var   Resampler.var(ddof=1, *args, **kwargs)[source]
 
Compute variance of groups, excluding missing values.  Parameters 
 
ddof:int, default 1


Degrees of freedom.    Returns 
 DataFrame or Series

Variance of values within each group.
pandas.core.window.ewm.ExponentialMovingWindow.corr   ExponentialMovingWindow.corr(other=None, pairwise=None, **kwargs)[source]
 
Calculate the ewm (exponential weighted moment) sample correlation.  Parameters 
 
other:Series or DataFrame, optional


If not supplied then will default to self and produce pairwise output.  
pairwise:bool, default None


If False then only matching columns between self and other will be used and the output will be a DataFrame. If True then all pairwise combinations will be calculated and the output will be a MultiIndex DataFrame in the case of DataFrame inputs. In the case of missing elements, only complete pairwise observations will be used.  **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.ewm

Calling ewm with Series data.  pandas.DataFrame.ewm

Calling ewm with DataFrames.  pandas.Series.corr

Aggregating corr for Series.  pandas.DataFrame.corr

Aggregating corr for DataFrame.
pandas.core.window.ewm.ExponentialMovingWindow.cov   ExponentialMovingWindow.cov(other=None, pairwise=None, bias=False, **kwargs)[source]
 
Calculate the ewm (exponential weighted moment) sample covariance.  Parameters 
 
other:Series or DataFrame , optional


If not supplied then will default to self and produce pairwise output.  
pairwise:bool, default None


If False then only matching columns between self and other will be used and the output will be a DataFrame. If True then all pairwise combinations will be calculated and the output will be a MultiIndex DataFrame in the case of DataFrame inputs. In the case of missing elements, only complete pairwise observations will be used.  
bias:bool, default False


Use a standard estimation bias correction.  **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.ewm

Calling ewm with Series data.  pandas.DataFrame.ewm

Calling ewm with DataFrames.  pandas.Series.cov

Aggregating cov for Series.  pandas.DataFrame.cov

Aggregating cov for DataFrame.
pandas.core.window.ewm.ExponentialMovingWindow.mean   ExponentialMovingWindow.mean(*args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the ewm (exponential weighted moment) mean.  Parameters 
 *args

For NumPy compatibility and will not have an effect on the result.  
engine:str, default None


 'cython' : Runs the operation through C-extensions from cython. 'numba' : Runs the operation through JIT compiled code from numba. 
None : Defaults to 'cython' or globally setting compute.use_numba  New in version 1.3.0.     
engine_kwargs:dict, default None


 For 'cython' engine, there are no accepted engine_kwargs 
For 'numba' engine, the engine can accept nopython, nogil and parallel dictionary keys. The values must either be True or False. The default engine_kwargs for the 'numba' engine is {'nopython': True, 'nogil': False, 'parallel': False}  New in version 1.3.0.     **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.ewm

Calling ewm with Series data.  pandas.DataFrame.ewm

Calling ewm with DataFrames.  pandas.Series.mean

Aggregating mean for Series.  pandas.DataFrame.mean

Aggregating mean for DataFrame.    Notes See Numba engine and Numba (JIT compilation) for extended documentation and performance considerations for the Numba engine.
pandas.core.window.ewm.ExponentialMovingWindow.std   ExponentialMovingWindow.std(bias=False, *args, **kwargs)[source]
 
Calculate the ewm (exponential weighted moment) standard deviation.  Parameters 
 
bias:bool, default False


Use a standard estimation bias correction.  *args

For NumPy compatibility and will not have an effect on the result.  **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.ewm

Calling ewm with Series data.  pandas.DataFrame.ewm

Calling ewm with DataFrames.  pandas.Series.std

Aggregating std for Series.  pandas.DataFrame.std

Aggregating std for DataFrame.
pandas.core.window.ewm.ExponentialMovingWindow.sum   ExponentialMovingWindow.sum(*args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the ewm (exponential weighted moment) sum.  Parameters 
 *args

For NumPy compatibility and will not have an effect on the result.  
engine:str, default None


 'cython' : Runs the operation through C-extensions from cython. 'numba' : Runs the operation through JIT compiled code from numba. 
None : Defaults to 'cython' or globally setting compute.use_numba  New in version 1.3.0.     
engine_kwargs:dict, default None


 For 'cython' engine, there are no accepted engine_kwargs 
For 'numba' engine, the engine can accept nopython, nogil and parallel dictionary keys. The values must either be True or False. The default engine_kwargs for the 'numba' engine is {'nopython': True, 'nogil': False, 'parallel': False}  New in version 1.3.0.     **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.ewm

Calling ewm with Series data.  pandas.DataFrame.ewm

Calling ewm with DataFrames.  pandas.Series.sum

Aggregating sum for Series.  pandas.DataFrame.sum

Aggregating sum for DataFrame.    Notes See Numba engine and Numba (JIT compilation) for extended documentation and performance considerations for the Numba engine.
pandas.core.window.ewm.ExponentialMovingWindow.var   ExponentialMovingWindow.var(bias=False, *args, **kwargs)[source]
 
Calculate the ewm (exponential weighted moment) variance.  Parameters 
 
bias:bool, default False


Use a standard estimation bias correction.  *args

For NumPy compatibility and will not have an effect on the result.  **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.ewm

Calling ewm with Series data.  pandas.DataFrame.ewm

Calling ewm with DataFrames.  pandas.Series.var

Aggregating var for Series.  pandas.DataFrame.var

Aggregating var for DataFrame.
pandas.core.window.expanding.Expanding.aggregate   Expanding.aggregate(func, *args, **kwargs)[source]
 
Aggregate using one or more operations over the specified axis.  Parameters 
 
func:function, str, list or dict


Function to use for aggregating the data. If a function, must either work when passed a Series/Dataframe or when passed to Series/Dataframe.apply. Accepted combinations are:  function string function name list of functions and/or function names, e.g. [np.sum, 'mean'] dict of axis labels -> functions, function names or list of such.   *args

Positional arguments to pass to func.  **kwargs

Keyword arguments to pass to func.    Returns 
 scalar, Series or DataFrame

The return can be:  scalar : when Series.agg is called with single function Series : when DataFrame.agg is called with a single function DataFrame : when DataFrame.agg is called with several functions  Return scalar, Series or DataFrame.      See also  pandas.DataFrame.aggregate

Similar DataFrame method.  pandas.Series.aggregate

Similar Series method.    Notes agg is an alias for aggregate. Use the alias. Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See Mutating with User Defined Function (UDF) methods for more details. A passed user-defined-function will be passed a Series for evaluation. Examples 
>>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})
>>> df
   A  B  C
0  1  4  7
1  2  5  8
2  3  6  9
  
>>> df.ewm(alpha=0.5).mean()
          A         B         C
0  1.000000  4.000000  7.000000
1  1.666667  4.666667  7.666667
2  2.428571  5.428571  8.428571
pandas.core.window.expanding.Expanding.apply   Expanding.apply(func, raw=False, engine=None, engine_kwargs=None, args=None, kwargs=None)[source]
 
Calculate the expanding custom aggregation function.  Parameters 
 
func:function


Must produce a single value from an ndarray input if raw=True or a single value from a Series if raw=False. Can also accept a Numba JIT function with engine='numba' specified.  Changed in version 1.0.0.   
raw:bool, default False


 False : passes each row or column as a Series to the function. True : the passed function will receive ndarray objects instead. If you are just applying a NumPy reduction function this will achieve much better performance.   
engine:str, default None


 'cython' : Runs rolling apply through C-extensions from cython. 'numba' : Runs rolling apply through JIT compiled code from numba. Only available when raw is set to True. 
None : Defaults to 'cython' or globally setting compute.use_numba  New in version 1.0.0.     
engine_kwargs:dict, default None


 For 'cython' engine, there are no accepted engine_kwargs 
For 'numba' engine, the engine can accept nopython, nogil and parallel dictionary keys. The values must either be True or False. The default engine_kwargs for the 'numba' engine is {'nopython': True, 'nogil': False, 'parallel': False} and will be applied to both the func and the apply rolling aggregation.  New in version 1.0.0.     
args:tuple, default None


Positional arguments to be passed into func.  
kwargs:dict, default None


Keyword arguments to be passed into func.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.apply

Aggregating apply for Series.  pandas.DataFrame.apply

Aggregating apply for DataFrame.
pandas.core.window.expanding.Expanding.corr   Expanding.corr(other=None, pairwise=None, ddof=1, **kwargs)[source]
 
Calculate the expanding correlation.  Parameters 
 
other:Series or DataFrame, optional


If not supplied then will default to self and produce pairwise output.  
pairwise:bool, default None


If False then only matching columns between self and other will be used and the output will be a DataFrame. If True then all pairwise combinations will be calculated and the output will be a MultiIndexed DataFrame in the case of DataFrame inputs. In the case of missing elements, only complete pairwise observations will be used.  **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  cov

Similar method to calculate covariance.  numpy.corrcoef

NumPy Pearson’s correlation calculation.  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.corr

Aggregating corr for Series.  pandas.DataFrame.corr

Aggregating corr for DataFrame.    Notes This function uses Pearson’s definition of correlation (https://en.wikipedia.org/wiki/Pearson_correlation_coefficient). When other is not specified, the output will be self correlation (e.g. all 1’s), except for DataFrame inputs with pairwise set to True. Function will return NaN for correlations of equal valued sequences; this is the result of a 0/0 division error. When pairwise is set to False, only matching columns between self and other will be used. When pairwise is set to True, the output will be a MultiIndex DataFrame with the original index on the first level, and the other DataFrame columns on the second level. In the case of missing elements, only complete pairwise observations will be used.
pandas.core.window.expanding.Expanding.count   Expanding.count()[source]
 
Calculate the expanding count of non NaN observations.  Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.count

Aggregating count for Series.  pandas.DataFrame.count

Aggregating count for DataFrame.
pandas.core.window.expanding.Expanding.cov   Expanding.cov(other=None, pairwise=None, ddof=1, **kwargs)[source]
 
Calculate the expanding sample covariance.  Parameters 
 
other:Series or DataFrame, optional


If not supplied then will default to self and produce pairwise output.  
pairwise:bool, default None


If False then only matching columns between self and other will be used and the output will be a DataFrame. If True then all pairwise combinations will be calculated and the output will be a MultiIndexed DataFrame in the case of DataFrame inputs. In the case of missing elements, only complete pairwise observations will be used.  
ddof:int, default 1


Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements.  **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.cov

Aggregating cov for Series.  pandas.DataFrame.cov

Aggregating cov for DataFrame.
pandas.core.window.expanding.Expanding.kurt   Expanding.kurt(**kwargs)[source]
 
Calculate the expanding Fisher’s definition of kurtosis without bias.  Parameters 
 **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  scipy.stats.kurtosis

Reference SciPy method.  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.kurt

Aggregating kurt for Series.  pandas.DataFrame.kurt

Aggregating kurt for DataFrame.    Notes A minimum of four periods is required for the calculation. Examples The example below will show a rolling calculation with a window size of four matching the equivalent function call using scipy.stats. 
>>> arr = [1, 2, 3, 4, 999]
>>> import scipy.stats
>>> print(f"{scipy.stats.kurtosis(arr[:-1], bias=False):.6f}")
-1.200000
>>> print(f"{scipy.stats.kurtosis(arr, bias=False):.6f}")
4.999874
>>> s = pd.Series(arr)
>>> s.expanding(4).kurt()
0         NaN
1         NaN
2         NaN
3   -1.200000
4    4.999874
dtype: float64
pandas.core.window.expanding.Expanding.max   Expanding.max(*args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the expanding maximum.  Parameters 
 *args

For NumPy compatibility and will not have an effect on the result.  
engine:str, default None


 'cython' : Runs the operation through C-extensions from cython. 'numba' : Runs the operation through JIT compiled code from numba. 
None : Defaults to 'cython' or globally setting compute.use_numba  New in version 1.3.0.     
engine_kwargs:dict, default None


 For 'cython' engine, there are no accepted engine_kwargs 
For 'numba' engine, the engine can accept nopython, nogil and parallel dictionary keys. The values must either be True or False. The default engine_kwargs for the 'numba' engine is {'nopython': True, 'nogil': False, 'parallel': False}  New in version 1.3.0.     **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.max

Aggregating max for Series.  pandas.DataFrame.max

Aggregating max for DataFrame.    Notes See Numba engine and Numba (JIT compilation) for extended documentation and performance considerations for the Numba engine.
pandas.core.window.expanding.Expanding.mean   Expanding.mean(*args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the expanding mean.  Parameters 
 *args

For NumPy compatibility and will not have an effect on the result.  
engine:str, default None


 'cython' : Runs the operation through C-extensions from cython. 'numba' : Runs the operation through JIT compiled code from numba. 
None : Defaults to 'cython' or globally setting compute.use_numba  New in version 1.3.0.     
engine_kwargs:dict, default None


 For 'cython' engine, there are no accepted engine_kwargs 
For 'numba' engine, the engine can accept nopython, nogil and parallel dictionary keys. The values must either be True or False. The default engine_kwargs for the 'numba' engine is {'nopython': True, 'nogil': False, 'parallel': False}  New in version 1.3.0.     **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.mean

Aggregating mean for Series.  pandas.DataFrame.mean

Aggregating mean for DataFrame.    Notes See Numba engine and Numba (JIT compilation) for extended documentation and performance considerations for the Numba engine.
pandas.core.window.expanding.Expanding.median   Expanding.median(engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the expanding median.  Parameters 
 
engine:str, default None


 'cython' : Runs the operation through C-extensions from cython. 'numba' : Runs the operation through JIT compiled code from numba. 
None : Defaults to 'cython' or globally setting compute.use_numba  New in version 1.3.0.     
engine_kwargs:dict, default None


 For 'cython' engine, there are no accepted engine_kwargs 
For 'numba' engine, the engine can accept nopython, nogil and parallel dictionary keys. The values must either be True or False. The default engine_kwargs for the 'numba' engine is {'nopython': True, 'nogil': False, 'parallel': False}  New in version 1.3.0.     **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.median

Aggregating median for Series.  pandas.DataFrame.median

Aggregating median for DataFrame.    Notes See Numba engine and Numba (JIT compilation) for extended documentation and performance considerations for the Numba engine.
pandas.core.window.expanding.Expanding.min   Expanding.min(*args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the expanding minimum.  Parameters 
 *args

For NumPy compatibility and will not have an effect on the result.  
engine:str, default None


 'cython' : Runs the operation through C-extensions from cython. 'numba' : Runs the operation through JIT compiled code from numba. 
None : Defaults to 'cython' or globally setting compute.use_numba  New in version 1.3.0.     
engine_kwargs:dict, default None


 For 'cython' engine, there are no accepted engine_kwargs 
For 'numba' engine, the engine can accept nopython, nogil and parallel dictionary keys. The values must either be True or False. The default engine_kwargs for the 'numba' engine is {'nopython': True, 'nogil': False, 'parallel': False}  New in version 1.3.0.     **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.min

Aggregating min for Series.  pandas.DataFrame.min

Aggregating min for DataFrame.    Notes See Numba engine and Numba (JIT compilation) for extended documentation and performance considerations for the Numba engine.
pandas.core.window.expanding.Expanding.quantile   Expanding.quantile(quantile, interpolation='linear', **kwargs)[source]
 
Calculate the expanding quantile.  Parameters 
 
quantile:float


Quantile to compute. 0 <= quantile <= 1.  
interpolation:{‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}


This optional parameter specifies the interpolation method to use, when the desired quantile lies between two data points i and j:  
 linear: i + (j - i) * fraction, where fraction is the fractional part of the index surrounded by i and j. lower: i. higher: j. nearest: i or j whichever is nearest. midpoint: (i + j) / 2.  
  **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.quantile

Aggregating quantile for Series.  pandas.DataFrame.quantile

Aggregating quantile for DataFrame.