`module` `coreforecast.lag_transforms`

`class` `Lag`

Simple lag operator

Args:

lag (int): Number of periods to offset

`method` `init`

__init__(lag: int)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(_idxs: ndarray) → _BaseLagTransform

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `RollingMean`

Rolling Mean

Args:

lag (int): Number of periods to offset by before applying the transformation.
window_size (int): Length of the rolling window.
min_samples (int, optional): Minimum number of samples required to compute the statistic. If None, defaults to window_size.

`method` `init`

__init__(lag: int, window_size: int, min_samples: Optional[int] = None)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(_idxs: ndarray) → _BaseLagTransform

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `RollingStd`

Rolling Standard Deviation

Args:

lag (int): Number of periods to offset by before applying the transformation.
window_size (int): Length of the rolling window.
min_samples (int, optional): Minimum number of samples required to compute the statistic. If None, defaults to window_size.

`method` `init`

__init__(lag: int, window_size: int, min_samples: Optional[int] = None)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(_idxs: ndarray) → _BaseLagTransform

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `RollingMin`

Rolling Minimum

Args:

lag (int): Number of periods to offset by before applying the transformation.
window_size (int): Length of the rolling window.
min_samples (int, optional): Minimum number of samples required to compute the statistic. If None, defaults to window_size.

`method` `init`

__init__(lag: int, window_size: int, min_samples: Optional[int] = None)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(_idxs: ndarray) → _BaseLagTransform

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `RollingMax`

Rolling Maximum

Args:

lag (int): Number of periods to offset by before applying the transformation.
window_size (int): Length of the rolling window.
min_samples (int, optional): Minimum number of samples required to compute the statistic. If None, defaults to window_size.

`method` `init`

__init__(lag: int, window_size: int, min_samples: Optional[int] = None)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(_idxs: ndarray) → _BaseLagTransform

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `RollingQuantile`

Rolling quantile

Args:

lag (int): Number of periods to offset by before applying the transformation
p (float): Quantile to compute
window_size (int): Length of the rolling window
min_samples (int, optional): Minimum number of samples required to compute the statistic. If None, defaults to window_size.

`method` `init`

__init__(
    lag: int,
    p: float,
    window_size: int,
    min_samples: Optional[int] = None
)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(_idxs: ndarray) → _BaseLagTransform

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `SeasonalRollingMean`

Seasonal rolling Mean

Args:

lag (int): Number of periods to offset by before applying the transformation
season_length (int): Length of the seasonal period, e.g. 7 for weekly data
window_size (int): Length of the rolling window
min_samples (int, optional): Minimum number of samples required to compute the statistic. If None, defaults to window_size.

`method` `init`

__init__(
    lag: int,
    season_length: int,
    window_size: int,
    min_samples: Optional[int] = None
)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(_idxs: ndarray) → _BaseLagTransform

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `SeasonalRollingStd`

Seasonal rolling Standard Deviation

Args:

lag (int): Number of periods to offset by before applying the transformation
season_length (int): Length of the seasonal period, e.g. 7 for weekly data
window_size (int): Length of the rolling window
min_samples (int, optional): Minimum number of samples required to compute the statistic. If None, defaults to window_size.

`method` `init`

__init__(
    lag: int,
    season_length: int,
    window_size: int,
    min_samples: Optional[int] = None
)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(_idxs: ndarray) → _BaseLagTransform

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `SeasonalRollingMin`

Seasonal rolling Minimum

Args:

lag (int): Number of periods to offset by before applying the transformation
season_length (int): Length of the seasonal period, e.g. 7 for weekly data
window_size (int): Length of the rolling window
min_samples (int, optional): Minimum number of samples required to compute the statistic. If None, defaults to window_size.

`method` `init`

__init__(
    lag: int,
    season_length: int,
    window_size: int,
    min_samples: Optional[int] = None
)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(_idxs: ndarray) → _BaseLagTransform

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `SeasonalRollingMax`

Seasonal rolling Maximum

Args:

lag (int): Number of periods to offset by before applying the transformation
season_length (int): Length of the seasonal period, e.g. 7 for weekly data
window_size (int): Length of the rolling window
min_samples (int, optional): Minimum number of samples required to compute the statistic. If None, defaults to window_size.

`method` `init`

__init__(
    lag: int,
    season_length: int,
    window_size: int,
    min_samples: Optional[int] = None
)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(_idxs: ndarray) → _BaseLagTransform

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `SeasonalRollingQuantile`

Seasonal rolling statistic

Args:

lag (int): Number of periods to offset by before applying the transformation
p (float): Quantile to compute
season_length (int): Length of the seasonal period, e.g. 7 for weekly data
window_size (int): Length of the rolling window
min_samples (int, optional): Minimum number of samples required to compute the statistic. If None, defaults to window_size.

`method` `init`

__init__(
    lag: int,
    p: float,
    season_length: int,
    window_size: int,
    min_samples: Optional[int] = None
)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(_idxs: ndarray) → _BaseLagTransform

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `ExpandingMean`

Expanding Mean

Args:

lag (int): Number of periods to offset by before applying the transformation

`method` `init`

__init__(lag: int)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(idxs: ndarray) → _ExpandingBase

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `ExpandingStd`

Expanding Standard Deviation

Args:

lag (int): Number of periods to offset by before applying the transformation

`method` `init`

__init__(lag: int)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(idxs: ndarray) → _ExpandingBase

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `ExpandingMin`

Expanding Minimum

Args:

lag (int): Number of periods to offset by before applying the transformation

`method` `init`

__init__(lag: int)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(idxs: ndarray) → _ExpandingBase

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `ExpandingMax`

Expanding Maximum

Args:

lag (int): Number of periods to offset by before applying the transformation

`method` `init`

__init__(lag: int)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(idxs: ndarray) → _ExpandingBase

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `ExpandingQuantile`

Expanding quantile

Args: lag (int): Number of periods to offset by before applying the transformation p (float): Quantile to compute

`method` `init`

__init__(lag: int, p: float)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(_idxs: ndarray) → _BaseLagTransform

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

`class` `ExponentiallyWeightedMean`

Exponentially weighted mean

Args:

lag (int): Number of periods to offset by before applying the transformation
alpha (float): Smoothing factor

`method` `init`

__init__(lag: int, alpha: float)

`method` `stack`

stack(transforms: Sequence[ForwardRef('_BaseLagTransform')]) → _BaseLagTransform

`method` `take`

take(idxs: ndarray) → ExponentiallyWeightedMean

`method` `transform`

transform(ga: GroupedArray) → ndarray

`method` `update`

update(ga: GroupedArray) → ndarray

This file was automatically generated via lazydocs.

API Reference

​module coreforecast.lag_transforms

​class Lag

​method __init__

​method stack

​method take

​method transform

​method update

​class RollingMean

​method __init__

​method stack

​method take

​method transform

​method update

​class RollingStd

​method __init__

​method stack

​method take

​method transform

​method update

​class RollingMin

​method __init__

​method stack

​method take

​method transform

​method update

​class RollingMax

​method __init__

​method stack

​method take

​method transform

​method update

​class RollingQuantile

​method __init__

​method stack

​method take

​method transform

​method update

​class SeasonalRollingMean

​method __init__

​method stack

​method take

​method transform

​method update

​class SeasonalRollingStd

​method __init__

​method stack

​method take

​method transform

​method update

​class SeasonalRollingMin

​method __init__

​method stack

​method take

​method transform

​method update

​class SeasonalRollingMax

​method __init__

​method stack

​method take

​method transform

​method update

​class SeasonalRollingQuantile

​method __init__

​method stack

​method take

​method transform

​method update

​class ExpandingMean

​method __init__

​method stack

​method take

​method transform

​method update

​class ExpandingStd

​method __init__

​method stack

​method take

​method transform

​method update

`module` `coreforecast.lag_transforms`

`class` `Lag`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `RollingMean`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `RollingStd`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `RollingMin`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `RollingMax`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `RollingQuantile`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `SeasonalRollingMean`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `SeasonalRollingStd`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `SeasonalRollingMin`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `SeasonalRollingMax`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `SeasonalRollingQuantile`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `ExpandingMean`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `ExpandingStd`

`method` `init`

`method` `stack`

`method` `take`

`method` `transform`

`method` `update`

`class` `ExpandingMin`