def range( self, start: Union[IntLike, DateLike, str], stop: Union[IntLike, DateLike, str], ) -> pd.DataFrame: if not self._extendable: raise TypeError( """The index in the deterministic process does not \ support extension. Only PeriodIndex, DatetimeIndex with a frequency, \ RangeIndex, and Int64Index that start at 0 and have only unit differences \ can be extended when producing out-of-sample forecasts. """) if type(self._index) in (pd.RangeIndex, pd.Int64Index): start = required_int_like(start, "start") stop = required_int_like(stop, "stop") # Add 1 to ensure that the end point is inclusive stop += 1 return self._range_from_range_index(start, stop) if isinstance(start, (int, np.integer)): start = self._int_to_timestamp(start, "start") else: start = pd.Timestamp(start) if isinstance(stop, (int, np.integer)): stop = self._int_to_timestamp(stop, "stop") else: stop = pd.Timestamp(stop) return self._range_from_time_index(start, stop)
def __init__( self, index: Union[Sequence[Hashable], pd.Index], *, period: Optional[Union[float, int]] = None, constant: bool = False, order: int = 0, seasonal: bool = False, fourier: int = 0, additional_terms: Sequence[DeterministicTerm] = (), drop: bool = False, ): if not isinstance(index, pd.Index): index = pd.Index(index) self._index = index self._deterministic_terms: List[DeterministicTerm] = [] self._extendable = False self._index_freq = None self._validate_index() period = float_like(period, "period", optional=True) self._constant = constant = bool_like(constant, "constant") self._order = required_int_like(order, "order") self._seasonal = seasonal = bool_like(seasonal, "seasonal") self._fourier = required_int_like(fourier, "fourier") additional_terms = tuple(additional_terms) self._cached_in_sample = None self._drop = bool_like(drop, "drop") self._additional_terms = additional_terms if constant or order: self._deterministic_terms.append(TimeTrend(constant, order)) if seasonal and fourier: raise ValueError( """seasonal and fourier can be initialized through the constructor since\ these will be necessarily perfectly collinear. Instead, you can pass \ additional components using the additional_terms input.""") if (seasonal or fourier) and period is None: if period is None: self._period = period = freq_to_period(self._index_freq) if seasonal: period = required_int_like(period, "period") self._deterministic_terms.append(Seasonality(period)) elif fourier: period = float_like(period, "period") assert period is not None self._deterministic_terms.append(Fourier(period, order=fourier)) for term in additional_terms: if not isinstance(term, DeterministicTerm): raise TypeError( "All additional terms must be instances of subsclasses " "of DeterministicTerm") if term not in self._deterministic_terms: self._deterministic_terms.append(term) else: raise ValueError( "One or more terms in additional_terms has been added " "through the parameters of the constructor. Terms must " "be unique.") self._period = period self._retain_cols: Optional[List[Hashable]] = None
def __init__(self, period: int, initial_period: int = 1) -> None: self._period = required_int_like(period, "period") self._initial_period = required_int_like(initial_period, "initial_period") if period < 2: raise ValueError("period must be >= 2") if not 1 <= self._initial_period <= period: raise ValueError("initial_period must be in {1, 2, ..., period}")
def out_of_sample( self, steps: int, forecast_index: Optional[Union[Sequence[Hashable], pd.Index]] = None, ) -> pd.DataFrame: steps = required_int_like(steps, "steps") if self._drop and self._retain_cols is None: self.in_sample() index = self._index if not self._deterministic_terms: return pd.DataFrame(np.empty((index.shape[0], 0)), index=index) raw_terms = [] for term in self._deterministic_terms: raw_terms.append(term.out_of_sample(steps, index, forecast_index)) terms: pd.DataFrame = pd.concat(raw_terms, axis=1) assert self._retain_cols is not None if terms.shape[1] != len(self._retain_cols): terms = terms[self._retain_cols] return terms
def __init__(self, freq: str, order: int) -> None: super().__init__(freq) FourierDeterministic.__init__(self, order) self._order = required_int_like(order, "terms")
def __init__(self, order: int) -> None: self._order = required_int_like(order, "terms")
def __init__(self, constant: bool = True, order: int = 0) -> None: self._constant = bool_like(constant, "constant") self._order = required_int_like(order, "order")