class_docstr: Test for stationarity via the Augmented Dickey-Fuller Unit Root Test (ADF).
  
  Direct interface to ``DFGLS`` test from the ``arch`` package.
  Does not assume ARCH process, naming is due to the use of the ``arch`` package.
  
  Uses ``arch.unitroot.ADF`` as a test for unit roots,
  and derives a boolean statement whether a series is stationary.
  
  Also returns test results for the unit root test as fitted parameters.
  
  Parameters
  ----------
  lags : int, optional
      The number of lags to use in the ADF regression.  If omitted or None,
      ``method`` is used to automatically select the lag length with no more
      than ``max_lags`` are included.
  trend : {"n", "c", "ct", "ctt"}, optional
      The trend component to include in the test
  
      - "n" - No trend components
      - "c" - Include a constant (Default)
      - "ct" - Include a constant and linear time trend
      - "ctt" - Include a constant and linear and quadratic time trends
  
  max_lags : int, optional
      The maximum number of lags to use when selecting lag length
  method : {"AIC", "BIC", "t-stat"}, optional
      The method to use when selecting the lag length
  
      - "AIC" - Select the minimum of the Akaike IC
      - "BIC" - Select the minimum of the Schwarz/Bayesian IC
      - "t-stat" - Select the minimum of the Schwarz/Bayesian IC
  
  low_memory : bool
      Flag indicating whether to use a low memory implementation of the
      lag selection algorithm. The low memory algorithm is slower than
      the standard algorithm but will use 2-4% of the memory required for
      the standard algorithm. This options allows automatic lag selection
      to be used in very long time series. If None, use automatic selection
      of algorithm.
  
  Attributes
  ----------
  stationary_ : bool
      whether the series in ``fit`` is stationary according to the test
      more precisely, whether the null of the ADF test is rejected at ``p_threshold``
  test_statistic_ : float
      The ADF test statistic, of running ``adfuller`` on ``y`` in ``fit``
  pvalue_ : float : float
      MacKinnon's approximate p-value based on MacKinnon (1994, 2010),
      obtained when running ``adfuller`` on ``y`` in ``fit``
  usedlag_ : int
      The number of lags used in the test.
  
  Examples
  --------
  >>> from sktime.datasets import load_airline
  >>> from sktime.param_est.stationarity import StationarityADFArch
  >>>
  >>> X = load_airline()  # doctest: +SKIP
  >>> sty_est = StationarityADFArch()  # doctest: +SKIP
  >>> sty_est.fit(X)  # doctest: +SKIP
  StationarityADFArch(...)
  >>> sty_est.get_fitted_params()["stationary"]  # doctest: +SKIP
  False
code: def __init__(
      self,
      lags=None,
      trend="c",
      max_lags=None,
      method="aic",
      low_memory=None,
      p_threshold=0.05,
  ):
      self.lags = lags
      self.trend = trend
      self.max_lags = max_lags
      self.method = method
      self.low_memory = low_memory
      self.p_threshold = p_threshold
      super().__init__()
  
imports: from sktime.param_est.base import BaseParamFitter
label_desc: Use image node_id 1 to create a new StationarityADFArch object from inherited base classes: BaseParamFitter with example: obj = StationarityADFArch(lags, trend, max_lags, method, low_memory, p_threshold)