neulab/docprompting-conala huggingface dataset:
pandas.core.window.expanding.Expanding.rank   Expanding.rank(method='average', ascending=True, pct=False, **kwargs)[source]
 
Calculate the expanding rank.  New in version 1.4.0.   Parameters 
 
method:{‘average’, ‘min’, ‘max’}, default ‘average’


How to rank the group of records that have the same value (i.e. ties):  average: average rank of the group min: lowest rank in the group max: highest rank in the group   
ascending:bool, default True


Whether or not the elements should be ranked in ascending order.  
pct:bool, default False


Whether or not to display the returned rankings in percentile form.  **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.rank

Aggregating rank for Series.  pandas.DataFrame.rank

Aggregating rank for DataFrame.    Examples 
>>> s = pd.Series([1, 4, 2, 3, 5, 3])
>>> s.expanding().rank()
0    1.0
1    2.0
2    2.0
3    3.0
4    5.0
5    3.5
dtype: float64
  
>>> s.expanding().rank(method="max")
0    1.0
1    2.0
2    2.0
3    3.0
4    5.0
5    4.0
dtype: float64
  
>>> s.expanding().rank(method="min")
0    1.0
1    2.0
2    2.0
3    3.0
4    5.0
5    3.0
dtype: float64
pandas.core.window.expanding.Expanding.sem   Expanding.sem(ddof=1, *args, **kwargs)[source]
 
Calculate the expanding standard error of mean.  Parameters 
 
ddof:int, default 1


Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements.  *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.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.sem

Aggregating sem for Series.  pandas.DataFrame.sem

Aggregating sem for DataFrame.    Notes A minimum of one period is required for the calculation. Examples 
>>> s = pd.Series([0, 1, 2, 3])
  
>>> s.expanding().sem()
0         NaN
1    0.707107
2    0.707107
3    0.745356
dtype: float64
pandas.core.window.expanding.Expanding.skew   Expanding.skew(**kwargs)[source]
 
Calculate the expanding unbiased skewness.  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.skew

Third moment of a probability density.  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.skew

Aggregating skew for Series.  pandas.DataFrame.skew

Aggregating skew for DataFrame.    Notes A minimum of three periods is required for the rolling calculation.
pandas.core.window.expanding.Expanding.std   Expanding.std(ddof=1, *args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the expanding standard deviation.  Parameters 
 
ddof:int, default 1


Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements.  *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.4.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.4.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  numpy.std

Equivalent method for NumPy array.  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.std

Aggregating std for Series.  pandas.DataFrame.std

Aggregating std for DataFrame.    Notes The default ddof of 1 used in Series.std() is different than the default ddof of 0 in numpy.std(). A minimum of one period is required for the rolling calculation. Examples 
>>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])
  
>>> s.expanding(3).std()
0         NaN
1         NaN
2    0.577350
3    0.957427
4    0.894427
5    0.836660
6    0.786796
dtype: float64
pandas.core.window.expanding.Expanding.sum   Expanding.sum(*args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the expanding 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.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding 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.expanding.Expanding.var   Expanding.var(ddof=1, *args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the expanding variance.  Parameters 
 
ddof:int, default 1


Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements.  *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.4.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.4.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  numpy.var

Equivalent method for NumPy array.  pandas.Series.expanding

Calling expanding with Series data.  pandas.DataFrame.expanding

Calling expanding with DataFrames.  pandas.Series.var

Aggregating var for Series.  pandas.DataFrame.var

Aggregating var for DataFrame.    Notes The default ddof of 1 used in Series.var() is different than the default ddof of 0 in numpy.var(). A minimum of one period is required for the rolling calculation. Examples 
>>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])
  
>>> s.expanding(3).var()
0         NaN
1         NaN
2    0.333333
3    0.916667
4    0.800000
5    0.700000
6    0.619048
dtype: float64
pandas.core.window.rolling.Rolling.aggregate   Rolling.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.Series.rolling

Calling object with Series data.  pandas.DataFrame.rolling

Calling object with DataFrame data.    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.rolling(2).sum()
     A     B     C
0  NaN   NaN   NaN
1  3.0   9.0  15.0
2  5.0  11.0  17.0
  
>>> df.rolling(2).agg({"A": "sum", "B": "min"})
     A    B
0  NaN  NaN
1  3.0  4.0
2  5.0  5.0
pandas.core.window.rolling.Rolling.apply   Rolling.apply(func, raw=False, engine=None, engine_kwargs=None, args=None, kwargs=None)[source]
 
Calculate the rolling 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.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.apply

Aggregating apply for Series.  pandas.DataFrame.apply

Aggregating apply for DataFrame.
pandas.core.window.rolling.Rolling.count   Rolling.count()[source]
 
Calculate the rolling 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.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.count

Aggregating count for Series.  pandas.DataFrame.count

Aggregating count for DataFrame.    Examples 
>>> s = pd.Series([2, 3, np.nan, 10])
>>> s.rolling(2).count()
0    1.0
1    2.0
2    1.0
3    1.0
dtype: float64
>>> s.rolling(3).count()
0    1.0
1    2.0
2    2.0
3    2.0
dtype: float64
>>> s.rolling(4).count()
0    1.0
1    2.0
2    2.0
3    3.0
dtype: float64
pandas.core.window.rolling.Rolling.cov   Rolling.cov(other=None, pairwise=None, ddof=1, **kwargs)[source]
 
Calculate the rolling 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.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.cov

Aggregating cov for Series.  pandas.DataFrame.cov

Aggregating cov for DataFrame.
pandas.core.window.rolling.Rolling.kurt   Rolling.kurt(**kwargs)[source]
 
Calculate the rolling 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.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling 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[1:], bias=False):.6f}")
3.999946
>>> s = pd.Series(arr)
>>> s.rolling(4).kurt()
0         NaN
1         NaN
2         NaN
3   -1.200000
4    3.999946
dtype: float64
pandas.core.window.rolling.Rolling.max   Rolling.max(*args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the rolling 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.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling 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.rolling.Rolling.mean   Rolling.mean(*args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the rolling 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.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling 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. Examples The below examples will show rolling mean calculations with window sizes of two and three, respectively. 
>>> s = pd.Series([1, 2, 3, 4])
>>> s.rolling(2).mean()
0    NaN
1    1.5
2    2.5
3    3.5
dtype: float64
  
>>> s.rolling(3).mean()
0    NaN
1    NaN
2    2.0
3    3.0
dtype: float64
pandas.core.window.rolling.Rolling.median   Rolling.median(engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the rolling 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.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling 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. Examples Compute the rolling median of a series with a window size of 3. 
>>> s = pd.Series([0, 1, 2, 3, 4])
>>> s.rolling(3).median()
0    NaN
1    NaN
2    1.0
3    2.0
4    3.0
dtype: float64
pandas.core.window.rolling.Rolling.min   Rolling.min(*args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the rolling 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.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling 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. Examples Performing a rolling minimum with a window size of 3. 
>>> s = pd.Series([4, 3, 5, 2, 6])
>>> s.rolling(3).min()
0    NaN
1    NaN
2    3.0
3    2.0
4    2.0
dtype: float64
pandas.core.window.rolling.Rolling.quantile   Rolling.quantile(quantile, interpolation='linear', **kwargs)[source]
 
Calculate the rolling 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.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.quantile

Aggregating quantile for Series.  pandas.DataFrame.quantile

Aggregating quantile for DataFrame.    Examples 
>>> s = pd.Series([1, 2, 3, 4])
>>> s.rolling(2).quantile(.4, interpolation='lower')
0    NaN
1    1.0
2    2.0
3    3.0
dtype: float64
  
>>> s.rolling(2).quantile(.4, interpolation='midpoint')
0    NaN
1    1.5
2    2.5
3    3.5
dtype: float64
pandas.core.window.rolling.Rolling.rank   Rolling.rank(method='average', ascending=True, pct=False, **kwargs)[source]
 
Calculate the rolling rank.  New in version 1.4.0.   Parameters 
 
method:{‘average’, ‘min’, ‘max’}, default ‘average’


How to rank the group of records that have the same value (i.e. ties):  average: average rank of the group min: lowest rank in the group max: highest rank in the group   
ascending:bool, default True


Whether or not the elements should be ranked in ascending order.  
pct:bool, default False


Whether or not to display the returned rankings in percentile form.  **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.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.rank

Aggregating rank for Series.  pandas.DataFrame.rank

Aggregating rank for DataFrame.    Examples 
>>> s = pd.Series([1, 4, 2, 3, 5, 3])
>>> s.rolling(3).rank()
0    NaN
1    NaN
2    2.0
3    2.0
4    3.0
5    1.5
dtype: float64
  
>>> s.rolling(3).rank(method="max")
0    NaN
1    NaN
2    2.0
3    2.0
4    3.0
5    2.0
dtype: float64
  
>>> s.rolling(3).rank(method="min")
0    NaN
1    NaN
2    2.0
3    2.0
4    3.0
5    1.0
dtype: float64